设计模式之单例模式

2016-12-17 本文已影响30人官先生Y

在学习《Android源码设计模式解析与实战》期间，自己的一些领悟并梳理成适合自己理解。

定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

使用场景

创建某种类型对象需要消耗过多的资源

单例模式代码实现

饿汉式

public class Singleton {  
     private static Singleton instance = new Singleton();  
     private Singleton (){
     }
     public static Singleton getInstance() {  
       return instance;  
     }  
 }

饿汉式是线程安全的，因为JVM保证只会装载一次，在装载类的时候是不会发生并发的。
饿汉式是以空间换时间。

懒汉式（线程不安全）

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

此懒汉式是线程不安全的。比如，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，就可能导致并发问题。

懒汉式（线程安全但是浪费资源）

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

在方法中加上synchronized可以解决线程不安全的问题，但每次调用getInstance，都要判断这样会降低整个访问的速度。可以用双重检查加锁。

懒汉式（双重检查加锁）

public class Singleton {  
      private volatile static Singleton singleton;  
      private Singleton (){
      }   
      public static Singleton getSingleton() {  
          if (singleton == null) {  
              synchronized (Singleton.class) {  
              if (singleton == null) {  
                  singleton = new Singleton();  
              }  
             }  
         }  
         return singleton;  
     }  
 }

可以看到getInstance方法中对instance进行了两次判空：第一次判断主要是为了避免不必要的同步，第二次判断是为了在null的情况下创建实例。

DCL失效问题

singleton = new Singleton(); 这是一句代码，但实际上它并不是一个原子操作，这句代码最终会被编译成多条指令，它大致做了3件事情：

给Singleton的实例分配内存
调用Singleton实例的构造函数，初始化成员字段
把singleton对象指向分配的内存空间（此时singleton就不是null了）。

DCL失效的场景以及原因：

由于Java编译器允许处理器乱序执行以及Java内存模型原因，导致2，3的执行顺序无法保证。当执行顺序是1-3-2时，线程A执行到3，执行权切换线程B，线程B调用getInstance()获取singleton时，此时singleton不为null，线程B拿到instance使用时就会出错，这就是DCL失效。

解决办法：

    /**
     * 添加volitile的修饰
     */
    private volatile static Singleton instance = null;

用volitile关键字修饰单例对象变量后，可以保证执行的顺序以及每次从主内存取，这样就解决了DCL失效问题。

在《Java并发编程实践》不赞成使用这样方式。

静态内部类单例模式

public class Singleton {

    /**
     * 静态内部类与外部类的实例没有绑定关系，而且只有被调用时才会
     * 加载，从而实现了延迟加载
     *
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static final Singleton instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

这种是推荐使用的单例模式实现方式。当第一次加载Singleton类时并不会初始化instance，只有在第一次调用getInstance方法时才会导致instance被初始化。这种方式不仅能够保证线程安全，也能保证单例对象的唯一性，同时也延迟实例化。

枚举单例

public enum Singleton {  
     INSTANCE;  
     public void method() {  
     }  
 }

枚举单例特点是：

写法简单
线程安全
防止反序列化重新创建新的对象

反序列化导致重新创建对象问题：

序列化和反序列化：

Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

反序列化过程中，依然可以通过特殊途径去创建新的实例。为了防止此情况发生，可以添加以下代码

    private Object readResolve() throws ObjectStreamException{
        return INSTANCE;
    }

也就是直接把INSTANCE返回，不再默认重新创建一个实例。

使用容器实现单例模式

public class SingletonManager { 
　　private static Map<String, Object> objMap = new HashMap<String,Object>();

　　private Singleton() { }
　　public static void registerService(String key, Objectinstance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;
　　　　}
　　}

　　public static ObjectgetService(String key) {
　　　　return objMap.get(key) ;
　　}
}

把多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

单例模式总结

不管以哪种形式实现单例模式，它们的核心原理是：

构造函数私有化
通过静态方法获取一个唯一的实例
在获取过程中必须保证线程安全、防止反系列化导致重新生成实例对象。

优点：

减少内存或者资源开支

缺点：

不利于扩展，只能通过修改代码实现