Singleton pattern的线程安全问题

original post from here
方法一：同步机制关键词
public class Singleton {
 2     //利用静态变量来记录Singleton的唯一实例
 3     private static Singleton uniqueInstance;
 4     
 5     /*
 6      * 构造器私有化，只有Singleton类内才可以调用构造器
 7      */
 8     private Singleton(){
 9         
10     }
11     
12     public static synchronized Singleton getInstance(){  //变为同步方法
13         if(uniqueInstance == null){
14             uniqueInstance = new Singleton();
15         }
16         
17         return uniqueInstance;
18     }
19     
20 }

方法二：
publicclass Singleton {

 2     /*
 3      * 利用静态变量来记录Singleton的唯一实例
 4      * 直接初始化静态变量，这样就可以确保线程安全了
 5      */
 6     private static Singleton uniqueInstance = new Singleton();   //直接初始化静态变量。
 7     
 8     /*
 9      * 构造器私有化，只有Singleton类内才可以调用构造器
10      */
11     private Singleton(){
12         
13     }
14     
15     public static Singleton getInstance(){
16         return uniqueInstance;
17     }

方法三：用“双重检查加锁”，在getInstance()中减少使用同步。

 public class Singleton {
 2     /*
 3      * 利用静态变量来记录Singleton的唯一实例
 4      * volatile 关键字确保：当uniqueInstance变量被初始化成Singleton实例时，
 5      * 多个线程正确地处理uniqueInstance变量
 6      * 
 7      */
 8     private volatile static Singleton uniqueInstance;
 9     
10     /*
11      * 构造器私有化，只有Singleton类内才可以调用构造器
12      */
13     private Singleton(){
14         
15     }
16     
17     /*
18      * 
19      * 检查实例，如果不存在，就进入同步区域
20      */
21     public static Singleton getInstance(){
22         if(uniqueInstance == null){
23             synchronized(Singleton.class){    //进入同步区域
24                 if(uniqueInstance == null){     //在检查一次，如果为null，则创建
25                     uniqueInstance  = new Singleton();
26                 }
27             }
28         }
29         
30         return uniqueInstance;
31     }
32     
33 }