单例模式

大家好,我叫噬魂

2.1单例模式介绍

单例模式的应用场景是:在一个应用中,应当只有一个ImageLoader实例,这个实例ImageLoader中又有线程池,缓存系统,网络请求等,这些都很消耗资源,所以应当采用单例模式。

2.2单例模式的定义

确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

2.3单例模式UML类图

图2-1

角色介绍:
Client----高层客户端
Singleton----单例类

---

实现单例模式有以下几个关键点:

1.构造函数不对外开放,一般为private;
2.通过一个静态方法或者枚举返回单例类对象;
3.确保单例类只有一个,尤其是在多线程的环境下;
4.确保单例类对象在反序列化时不会重新构建对象(这个可能是很多人没有注意到的)。
在获取单例对象的时候,我们要确保线程安全,在多线程环境也只有一个对象,这在单例模式实现中比较困难。

2.4单例模式的简单实现

示例实现代码 coding

package com.dp.example.singleton;
//普通员工
public class Staff{
    public void work(){
        //干活
    }
}
//副总裁
public class VP extends Staff{
    @override
    public void work(){
    //管理下面的经理
    }
}

//CEO,恶汉单例模式
public class CEO extends Staff{
    private static final CEO mCeo = new CEO();
    //构造函数私有
    private CEO(){

    }
  //公有的静态方法,对外暴露获取单例对象的接口
  public static CEO getCeo(){
    return mCeo;
  }

  @override
  public void work(){
      //管理vp
  }
}

//公司类
public class Company{
    private List<Staff> allStaffs = new ArrayList<Staff>;
    public void addStaff(Staff per){
        allStaff.add(per);
    }

    public void showAllStaffs(){
        for (Staff per: allStaffs ) {
            System.out.println("Obj: "+ per.toString());
        }
    }
}

public class Test{
    public static void man(String[] args){
    Company cp = new Company();
    //CEO对象只能用getCeo函数获取
    Staff ceo1 = CEO.getCeo();
    Staff ceo2 = CEO.getCeo();
    cp.addStaff(ceo1);
    cp.addStaff(ceo2);
    //通过new创建vp对象
    Staff vp1 = new VP();
    Staff vp2 = new VP();
    //通过new创建staff对象
    Staff staff1 = new Staff();
    Staff staff2 = new Staff();
    Staff staff3 = new Staff();
    cp.addStaff(vp1);
    cp.addStaff(vp2);
    cp.addStaff(staff1);
    cp.addStaff(staff2);
    cp.addStaff(staff3);

    cp.showAllStaffs();
    }
}

2.5单例模式的其他实现方式

懒汉模式

 public class singleton{
    private static singleton instance;
    private singleton (){};
    
    public static synchronized singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    } 
}

我们在getInstance()方法中添加了synchronized关键字，也就是一个同步方法，这是为了保证在多线程中对象唯一性的手段，不过这里有一个问题，就是当instance已经被初始化了之后，以后每次调用geitInstance方法都会进行同步操作，这样会消耗不必要的资源，这就是懒汉式存在的最大问题。

---

最后总结一下：懒汉式的优点是单例只有在使用时才会实例化，在一定程度上节约了资源，缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是当我们用geitIntance时，每次都要同步，这样就造成了不必要的开销，懒汉式这种模式我们一般不推荐使用，我们还是建议使用下面几种方式。

Double Check Lock(DCL)

DCL方式实现单例模式的优点是既能够在需要的时候才初始化单例，又能够保证线程安全，且单例对象初始化之后调用getInstance不进行同步锁。

public class Singleton{
  private static Singleton sInstance = null;
  private Singleton(){};
  public void doSometing(){
    System.out.println("do sth.");
  }
  
  public static Singleton getInstance(){
    if(sInstance == null){
      synchronized (Singleton.class){
        if(sInstance == null){
          sIntance = new Singleton();
        }
      }
    }
    return sIntance;
  }
}

---

下面是比较好的实现方式

2.6 静态内部类单例模式

public class Singleton{
  private Singleton(){};
  public static Singleton getInstance(){
    return SingletonHolder.sInstance;
  }

  /**
   *静态内部类
   */
  private static class SingletonHolder{
    private static final Singleton sInstance = new Singleton();
  }
}

这种方式是我们推荐的方式。