同步锁的失败也许

2012-10-28

同步锁的失败可能以下例子参考http://developer.51cto.com/art/201104/256239.htm网上闲逛时发现一篇博文，

同步锁的失败可能
以下例子参考http://developer.51cto.com/art/201104/256239.htm

网上闲逛时发现一篇博文，讲的是单例同步锁时失败的可能，提到的错误自己基本都忽略了，下面以其中的例子说一下自己的理解。

单例模式是比较简单直接的：

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

这也是在初学单例模式时会提到的一个采用延迟加载实现的例子，实际上这个例子并不能“保证”单例，在多线程高并发的情况下，如果瞬间同时初始访问getInstance方法，返回的可能就是不同的实例。于是就有了下面的简单的同步机制：

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

这种方式保证了线程安全，但是我们只需要在生成实例的过程中保证其同步即可，不需要对访问也进行加锁。很明显，简单的在类实例范围内对其加锁，性能是其瓶颈。为了避免这种情况，便会有下面的想法：

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;      }}

        其实这样便可以保证单例了，但是却保证不了单例的准确性。也就是说不同的线程可以拿到同一个实例，但是在某些情况下，会取到实例的错误状态。在本例中，初始化Singleton对象和将对象地址赋给instance的顺序是不确定的。也即可能有以下两种情况：
        1、在初始化之前将对象引用赋给instance。这时，instance有了实际的引用，但对象还没有初始化。其他线程此时如果获取到instance，可能就是只有引用而还没有初始化的实例。
        2、在初始化之后将对象引用赋给instance。这是正确的状态，保证了单例也保证了正确性。

        这种不确定性不能“保证”单例的正确性。再看下面的改进方案：

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

这种方式制造了一个内存屏障，即使用了一个临时变量来保证“初始化操作和赋引用操作”的原子性。这种方式从代码方面看已经没有问题了，但是注意到在同步语句块之外的instance=temp，根据博文的解释：同步语句块内的操作必须在语句块结束之前完成，但是代码中同步块之外的操作有可能被编译器放到块内执行（只是存在这种可能性）。这一点细节确实不容易考虑到，需要了解一些JVM的知识，这方面没什么研究，保留意见。
看最后一种方式：

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;      }  }

这里要说一下volatile关键字，这个除了在一定程度上确保同步之外，JDK1.5扩充了volatile语义，简单点说就是保证了对象初始化以及赋引用的有序性，在本例来说就是先初始化后赋引用。这样两层机制保证了单例的唯一性和准确性。

热点排行

编程

同步锁的失败也许