单例模式与DCL

在一些人的印象中，懒汉式单例可能是这样的：



public class Singleton {



    private static Singleton instance = null;

    private Singleton(){}




    public synchronized static Singleton getInstance() {



       if(instance == null) {

           instance = new Singleton();

       }



       return instance;

    }



}



这种写法，是安全的，不会产生多个实例。但是这种写法有个问题就是把synchronized关键字加在方法签名上，导致多线程访问的时候，锁是加在Singleton.class这个对象上的。每次调用getInstance都需要取得Singleton.class上的锁，然而该锁只是在开始构建Singleton 对象的时候才是必要的，后续的多线程访问，效率会降低，于是有了接下来的版本：



public class Singleton {

    private static Singleton instance = null;

    private Singleton(){}



    public static Singleton getInstance() {

       if(instance == null) {

           synchronized(Singleton.class) {

              if(instance == null) {

                  instance = new Singleton();

              }

           }

       }



       return instance;



    }

}



这种写法，看上去很美，甚至被当作懒汉式单例的正确版本广为流传。不幸的是，这个版本也是错误的。这和DCL有关。虽然我也听说过java中双重检查成例是失效的，但是没有弄得很清楚到底它是怎么失效的，依稀记得跟编译器优化代码有关系。今天看了一些资料，终于明白了大概：

上述代码，并不会产生两个Singleton实例，它的错误表现在虽然一个线程得到了Singleton的实例，但是里面的状态是不对的。如果要弄明白具体的意思，来看一下下面的例子：



# public class LazySingleton {

#     private int someField;

#     

#     private static LazySingleton instance;

#     

#     private LazySingleton() {

#         this.someField = new Random().nextInt(200)+1;         // (1)

#     }

#     

#     public static LazySingleton getInstance() {

#         if (instance == null) {                               // (2)

#             synchronized(LazySingleton.class) {               // (3)

#                 if (instance == null) {                       // (4)

#                     instance = new LazySingleton();           // (5)

#                 }

#             }

#         }

#         return instance;                                      // (6)

#     }

#     

#     public int getSomeField() {

#         return this.someField;                                // (7)

#     }

# }

这也是同样错误的懒汉式单例，和上面不同之处是多了一个someField，以及相应的赋值和取值代码。这个单例，在某些极端的情况下会发生这样的现象：线程X获得了单例，但是调用getSomeField()的时候，取到的值并不是一个大于1的随机数，而是0.这种情况仅仅可能发生在初次调用的时候，而且是多个线程几乎同时调用的时候。由于构造方法的调用在字节码中并不是一个指令，而是4到5个指令。比如最简单的new一个String，字节码如下：

String str = new String();



是分成下面几条指令执行的：

0:   new     #2; //class java/lang/String

1:   dup

2:   invokespecial   #3; //Method java/lang/String."<init>":()V

3:   astore_1



这样就会出现一种情况，实例已经创建了，但是构造方法还没被调用(<init>没被调用)。导致这个实例中的field都是默认的。



解决这个问题的办法是使用一个静态内部类来保存实例。如下面所示：



public class Something {

      

    private Something() {

        }



    private static class LazyHolder {

        public static final Something INSTANCE = new Something();

    }



    public static Something getInstance() {

        return LazyHolder.INSTANCE;



    }

}





或者，在JDK1.5之后，还可以采用另外一种办法，使用volatile关键字：



在JDK1.5及其后续版本中，扩充了volatile语义，系统将不允许对 写入一个volatile变 量的操作与其之前的任何读写操作 重新排序，也不允许将 读取一个volatile变量的操作与其之后的任何读写操作 重新排序。

在jdk1.5及其后的版本中，可以将instance 设置成volatile以让双重检查锁定生效，如下：

public class Singleton {

    private static volatile Singleton instance = null;

    private Singleton(){}

  

    public static Singleton getInstance() {

       if(instance == null) {

           synchronized(Singleton.class) {

              if(instance == null) {

                  instance = new Singleton();

              }

           }

       }

       return instance;

    }

}






看似小小的单例问题，竟然可以牵涉那么多的深层次问题。值得令人深思。





主题：用happen-before规则重新审视DCL http://www.iteye.com/topic/260515

双重检查锁定失败可能性——参照《The "Double-Checked Locking is Broken" Declaration》 http://freish.iteye.com/blog/1008304#bc2248177