Java并发笔记——单例与双重检测

Posted 2020-10-06 纳兰小依

       单例模式可以使得一个类只有一个对象实例，能够减少频繁创建对象的时间和空间开销。单线程模式下一个典型的单例模式代码如下：

①

 1 class Singleton{
 2     private static Singleton singleton;    
 3     private Singleton(){}
 4     
 5     public static Singleton getInstance(){
 6         if(singleton == null){
 7             singleton = new Singleton();   //1
 8         }
 9         return singleton;
10     }
11 }

       构造器私有使得外界无法通过构造器实例化Singleton类，要取得实例只能通过getInstance()方法。这是一个延迟加载的版本，即在需要对象的时候才进行实例化操作。该方法在单线程下能够正常运行，但是在多线程环境下会出现由于没有同步措施而导致产生多个单例对象的情况。原因在于可能同时有两个线程A和B同时执行到 if 条件判断语句，A判断singleton为空准备执行//1时让出了CPU时间片，B也判断singleton为空，接着执行//1，此时创建了一个实例对象；A获取了CPU时间片后接着执行//1，也创建了实例对象，这就导致多个单例对象的情况。

       解决问题的方法也很简单，使用synchronized关键字：

②

 1 class Singleton{
 2     private static Singleton singleton;    
 3     private Singleton(){}
 4     
 5     public static synchronized Singleton getInstance(){
 6         if(singleton == null){
 7             singleton = new Singleton();    //1
 8         }
 9         return singleton;
10     }
11 }

        这样解决了多线程并发的问题，但是却带来了效率问题：我们的目的是只创建一个实例，即//1处代码只会执行一次，也正是这个地方才需要同步，后面创建了实例之后，singleton非空就会直接返回对象引用，而不用每次都在同步代码块中进行非空验证。那么可以考虑只对//1处进行同步：

③

 1 class Singleton{
 2     private static Singleton singleton;    
 3     private Singleton(){}
 4     
 5     public static Singleton getInstance(){
 6         if(singleton == null){
 7             synchronized(Singleton.class){                
 8                 singleton = new Singleton();   //1
 9             }
10         }
11         return singleton;
12     }
13 }

       这样会带来与第一种一样的问题，即多个线程同时执行到条件判断语句时，会创建多个实例。问题在于当一个线程创建一个实例之后，singleton就不再为空了，但是后续的线程并没有做第二次非空检查。那么很明显，在同步代码块中应该再次做检查，也就是所谓的双重检测：

④双重检测：

 1 class Singleton{
 2     private static Singleton singleton;    
 3     private Singleton(){}
 4     
 5     public static Singleton getInstance(){
 6         if(singleton == null){
 7             synchronized(Singleton.class){
 8                 if(singleton == null)
 9                     singleton = new Singleton();   //1
10             }
11         }
12         return singleton;
13     }
14 }

       到这里已经很完美了，看起来没有问题。但是这种双重检测机制在JDK1.5之前是有问题的，问题还是出在//1，由所谓的无序写入造成的。一般来讲，当初始化一个对象的时候，会经历内存分配、初始化、返回对象在堆上的引用等一系列操作，这种方式产生的对象是一个完整的对象，可以正常使用。但是JAVA的无序写入可能会造成顺序的颠倒，即内存分配、返回对象引用、初始化的顺序，这种情况下对应到//1就是singleton已经不是null，而是指向了堆上的一个对象，但是该对象却还没有完成初始化动作。当后续的线程发现singleton不是null而直接使用的时候，就会出现意料之外的问题。

        JDK1.5之后，可以使用volatile关键字修饰变量来解决无序写入产生的问题，因为volatile关键字的一个重要作用是禁止指令重排序，即保证不会出现内存分配、返回对象引用、初始化这样的顺序，从而使得双重检测真正发挥作用。

       当然，也可以选择不使用双重检测，而采用非延迟加载的方式来达到相同的效果：

1 class Singleton{
2     private static Singleton singleton = new Singleton();    
3     private Singleton(){}
4     
5     public static Singleton getInstance(){
6         return singleton;
7     }
8 }

【参考】

Java单例模式中双重检查锁的问题

单例模式与双重检测

Java 中的双重检查（Double-Check）

Java并发编程：volatile关键字解析