Design Pattern -- 单例模式

单例模式是设计模式中最常用到的一种模式,一般应用于定位管理、线程管理、文件管理、网络管理等类上面,让这些类的单一实例来处理App的各个模块逻辑等。
这里我就不多举例子了,相信大家应该都会用,我就将基本所有类型的单例实现方式列举出来,供大家参考吧。

(1)几种常见的单例模式模板

  1. 饿汉单例

“饿汉”,指的是代码很早就想要初始化实例出来,于是,此形式的类实例在类编译加载在内存中的时候就初始化创建完毕。

public class Singleton{
     private static Singleton sInstance = new SingleTon();

     private Singleton() {}

     public Singleton getInstance(){
           return sInstance;
     }
}

优点:类加载时实例化对象,避免了多线程同步创建问题。
缺点:类加载时就进行初始化,即还没用到它,它就占了App进程的部分内存,造成一定的内存浪费。【没有懒加载】

  1. 懒汉单例(加了synchronized,保证线程安全)

“懒汉”,相对于“饿汉”来说,就不是在编译时急着初始化了,而是在调用到类静态方法要用到一个实例时,他再初始化单例对象。

public class LazySingleTon {
  private static LazySingleTon sInstance;
  
  private LazySingleTon(){
  }
  
  public static synchronized LazySingleTon getInstance(){
      if(sInstance==null){
          sInstance = new LazySingleTon();
      }
      return sInstance;
  }
}

注意,以上的code,方法加synchronized与否,直接影响读取性能。

  1. DCL 单例(双重检查锁定)
public class DCLSingleTon {

//  private static DCLSingleTon sInstance;
    private volatile static DCLSingleTon sInstance = null;
    ///考虑到 DCL失效问题:JDK1.5之前的JMM(Java内存模型)中的Cache、寄存器到主内存回写顺序的规定,上面三件事中的后面两件事的顺序无法保证。
    ///这样,如果是执行1->3->2的执行顺序,那么,在内部成员都没有被初始化的情况下,sInstance就已经被赋值为非null了,那就后面会产生错误了。
    ///于是,>=JDK1.5时,可以这样:
//  private volatile static DCLSingleTon sInstance = null;
    ///虽然这样,加载时会影响性能,但是,还是值得的。
    ///这样一来,就可以每次在主内存中读取对象了。
    
    private DCLSingleTon(){
        
    }
    
    public static DCLSingleTon getInstance(){
        
        if(sInstance== null){
            synchronized (DCLSingleTon.class) {
                if(sInstance == null){
                    sInstance = new DCLSingleTon();
                }
            }
        }
        return sInstance;
    }
}
  • 优点:既能够在需要时才初始化单例【懒加载】,又能够保证线程安全,而且,单例对象初始化后的getInstance调用是不会进行同步锁的【第一次要初始化对象所以慢,第二次之后就很快】。
  • 缺点:加入了volatile关键字(JDK1.5以上),保证Java编译器执行顺序,但影响了性能。【不过,这个影响很小】
  1. 静态内部类单例【推荐】
public class StaticSingleTon {
    private static StaticSingleTon sInstance;
    
    private StaticSingleTon(){}
    
    public static StaticSingleTon getInstance(){
        return StaticSingleTon.sInstance;
    }
    /// 静态内部类
    private static class SingleTonHolder{
        private static final StaticSingleTon sInstance = new StaticSingleTon();
    }
}
  • 特点:同样 是 只有第一次调用getInstance()时,才会加载SingleTonHolder类,也才会初始化对象。
  • 解决了DCL乱序问题【不怕他会执行乱序。一定是先初始化对象,然后获取对象。】
  1. 枚举单例
public enum EnumSingleTon {
    DOG,CAT;
    public void bark(){
      System.out.println(toString()+"吠了一声!");   
    }
}

然后,我们可以直接调用:

DOG.bark();
DOG.bark();
CAT.bark();
CAT.bark();

永远只存在一条狗和一只猫的实例。

  • 优点:解决了对象反序列化问题(任何时候都是单例)
  • 什么是“反序列化问题”? 答:就是,即使你的单例类的构造器是private的,但是到反序列化那一步的时候,依然会通过特殊手段去调用该方法,来实例化一个新的实例。【so,将对象写入磁盘,再读取出来的过程,就会新建对象,而不是用回原来的实例。】
  1. 使用容器
    使用容器,同样能实现单例模式。
public class SingleTonManager {
    private static Map<String, Object> objMap = new HashMap<String,Object>();
    
    private SingleTonManager(){}
    
    public static void registerService(String key , Object instance){
        if(! objMap.containsKey(key)){
            objMap.put(key, instance);
        }
    }
    
    public static Object getInstance(String key){
        return objMap.get(key);
    }
}

推荐阅读更多精彩内容