对单例模式的优化、双重检查锁的原理

 

                                                                     对单例模式的优化

（1）从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题。如下示例：

1. public static  Singleton getInstance(){  
2.     if(instance == null){  
3.         instance = new Singleton();  
4.     }  
5.     return instance;  
6. } 

程序继续运行，两个线程都向前走了一步，如下：

1. public static  Singleton getInstance(){  
2.     if(instance == null){  
3.          instance = new Singleton();  
4.     }  
5.     return instance;  
6. } 

可能有些朋友会觉得文字描述还是不够直观，再来画个图说明一下，如图5.4所示。

（点击查看大图）图5.4  懒汉式单例的线程问题示意图

通过图5.4的分解描述，明显地看出，当A、B线程并发的情况下，会创建出两个实例来，也就是单例的控制在并发情况下失效了。

（2）饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

（3）如何实现懒汉式的线程安全呢？

当然懒汉式也是可以实现线程安全的，只要加上synchronized即可，如下：

1. public static synchronized Singleton getInstance(){} 

但是这样一来，会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式来实现呢？

（4）双重检查加锁

可以使用"双重检查加锁"的方式来实现，就可以既实现线程安全，又能够使性能不受到很大的影响。那么什么是"双重检查加锁"机制呢？

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：这里volatile只是为了防止 instance = new Singleton();操作时发生指令重排。因为指令重排可能导致返回一个错误的instance对象引用，因此可能导致new Singleton（）没完成，而其他线程取到了一个错误的对象实例。

看看代码可能会更加清楚些。示例代码如下：

1. public class Singleton {  
2.     /**  
3.      * 对保存实例的变量添加volatile的修饰  ：防止指令重排
4.      */  
5.     private volatile static Singleton instance = null;  
6.     private Singleton(){  
7.     }  
8.     public static  Singleton getInstance(){  
9.         //先检查实例是否存在，如果不存在才进入下面的同步块  
10.         if(instance == null){  
11.             //同步块，线程安全地创建实例  
12.             synchronized(Singleton.class){  
13.                 //再次检查实例是否存在，如果不存在才真正地创建实例  
14.                 if(instance == null){  
15.                     instance = new Singleton();  
16.                 }  
17.             }  
18.         }  
19.         return instance;  
20.     }  
21. } 

这种实现方式可以实现既线程安全地创建实例，而又不会对性能造成太大的影响。它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。