双检锁（Double-checked Locking）

双检锁英文又称Double-checked Locking，是在实际开发过程中对多线程单例模式下的延迟加载需求所提出的一个方案。
下面是一个基本的单例模式

 
package cn.fsf.thread; 
public class DoubleCheckedLock { 
    private static DoubleCheckedLock aInstance = new DoubleCheckedLock(); 
    public static DoubleCheckedLock getInstance() { 
        return aInstance; 
    } 
} 

为了提高系统启动速度，我们决定使用延时加载技术，于是对其进行了改进

package cn.fsf.thread;

public class DoubleCheckedLock {
	private static DoubleCheckedLock aInstance;

	public static DoubleCheckedLock getInstance() {
		if (aInstance == null) {
			aInstance = new DoubleCheckedLock();
		}
		return aInstance;
	}
}

现在该类需要在多线程环境下工作，于是又对其进行了改进

package cn.fsf.thread;

public class DoubleCheckedLock {
	private static DoubleCheckedLock aInstance;

	public static synchronized DoubleCheckedLock getInstance() {
		if (aInstance == null) {
			aInstance = new DoubleCheckedLock();
		}
		return aInstance;
	}
}

这样的代码已经能够正常工作了，但是其性能却不甚乐观，为什么呢？原因在于getInstance()方法整个方法体都是同步的，这就限定了其访问速度，最关键的是其实我们增加同步的关键仅仅是同步首次初始化该对象，而对于之后的获取却是不需要进行同步锁定的。于是有人就又做了进一步的改进

package cn.fsf.thread;

public class DoubleCheckedLock {
	private static DoubleCheckedLock aInstance;

	public static DoubleCheckedLock getInstance() {
		if (aInstance == null) {
			synchronized (DoubleCheckedLock.class) {
				if (aInstance == null) {
					aInstance = new DoubleCheckedLock();
				}
			}
		}
		return aInstance;
	}
}

这次改进把同步放到了方法体内，这样仅在第一次调用初始化时才会进入同步代码块，之后便巧妙的避开了同步锁定。大家看这样的代码有问题么？

遗憾的是，这段代码存在很隐蔽的错误，这样的写法在一些平台和优化编译器上可能导致一些问题。

原因在于初始化对象的过程并不是原子操作。
对于 aInstance = new DoubleCheckedLock();一些编译器可以这样处理：
1，aInstantce=新分配的内存地址。
2，执行DoubleCheckedLock的构造函数进行变量初始化。
问题就来了，假如线程A刚执行完第一步，CPU时间耗尽，线程B进入判断第一次的aInstance == null 就不成立了，因为它已经有内存地址了，所以就直接返回了这个对象，但是这个对象还没有被合理的初始化，这样就造成了很隐蔽的错误。

有没有解决的办法呢，
方案一：使用标志位避免对象初始化未完成被其他进程误用

package cn.fsf.thread;

public class DoubleCheckedLock {
	private static DoubleCheckedLock aInstance;
	private static boolean isInstanced;

	public static DoubleCheckedLock getInstance() {
		if (!isInstanced) {
			synchronized (DoubleCheckedLock.class) {
				if (aInstance == null) {
					aInstance = new DoubleCheckedLock();
					isInstanced = true;
				}
			}
		}
		return aInstance;
	}
}

此方法为个人所想出，如您发现有不妥之处，请指出~

评论

7 楼 deyami 2012-05-29  

”问题就来了，假如线程A刚执行完第一步，CPU时间耗尽，线程B进入判断第一次的aInstance == null 就不成立了，因为它已经有内存地址了“

这句话依据从何而来？在synchronized中会发生换出？

6 楼 wzb56 2012-04-28  

package cn.fsf.thread;

public class DoubleCheckedLock {
	private static DoubleCheckedLock aInstance;

	public static DoubleCheckedLock getInstance() {
		if (aInstance == null) {
			synchronized (DoubleCheckedLock.class) {
				if (aInstance == null) {
					DoubleCheckedLock tmp = new DoubleCheckedLock();
                                        aInstance = tmp;
				}
			}
		}
		return aInstance;
	}
}

5 楼 wzb56 2012-04-28  

package cn.fsf.thread;

public class DoubleCheckedLock {
       private DoubleCheckedLock() {}
       
private static DoubleCheckedLock aInstance;

public static DoubleCheckedLock getInstance() {
if (aInstance == null) {
synchronized (DoubleCheckedLock.class) {
if (aInstance == null) {
DoubleCheckedLOck tmp = new DoubleCheckedLock();
                                      aInstance  = tmp;
}
}
}
return aInstance;
}
}

4 楼 wolfcame 2012-02-02  

嗯 谢谢你的意见~

3 楼 iamiwell 2012-02-02  

isInstanced和aInstance是没有数据依赖的，所以在两种情况下都没有顺序保证：
1）编译器做优化的时候(c编译器)，因为没有数据依赖，可能为了辅助CPU的流水处理，会重排代码，当然，得根据具体编译器而言，但可以确定的是，既然没有数据依赖，那就没有确定顺序，除非自己添加屏障(java版的volatile的JVM实现就用到了优化屏障)
2) CPU的乱序处理，既然没有数据依赖，那谁先谁后就看CPU了，同样，java版的volatile也是因为增加了内存屏障才予以保证；
我记得这个问题，网上资料应该还蛮多的。

2 楼 wolfcame 2012-02-02  

iamiwell 写道

其实你这种方法，理论上错误依旧，如果aInstantce=新分配的内存地址和isInstanced = true
，都在init之前完成呢。
一种方式：不需要isInstanced，aInstance声明成volatile；
或者，声明isInstanced为volatile也行；

首先，我也考虑到过你说的这个问题，就是isInstanced=true在init之前被调用了，但是这种情况会出现么？我感觉出现的前提是编译器颠倒了代码的执行顺序把isInstanced=true提到了前面执行，否则应该会在init完之后才会调用isInstanced=true这句才对。
其次，假设存在编译器会颠倒代码顺序的情况，那么我们设想下这个在单线程情况下代码的执行情况也就没办法保证了：

1,MyClass myClass = new MyClass();
2,myClass.getXX();

那么现在这个普通的情况下也不能保证在new MyClass()完成init之后才会调用getXX()了，如果是这样，显然java语言稳定性就极差了。所以反过来讲，我觉得应该不会出现这样的情况。

1 楼 iamiwell 2012-02-02  

其实你这种方法，理论上错误依旧，如果aInstantce=新分配的内存地址和isInstanced = true
，都在init之前完成呢。
一种方式：不需要isInstanced，aInstance声明成volatile；
或者，声明isInstanced为volatile也行；