代码如下所示
public class Singleton{
private Singleton singleton;
public static Singleton getInstance()
{
if (instance == null)
{
synchronized(Singleton.class) {
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
}
先说说为何需要使用DCL
- 延迟初始化,减少程序启动时间
- 延迟初始化需要使用同步,但同步速度慢,所以先使用null判断
- 等new的时候,需要保证原子性,所以加锁
DCL带来的问题
-
可见性无法保证
线程安全:原子性、可见性
简而言之:
a线程更改对象y -> 更改CPU缓存1中的y -> 写入内存中的y
b线程读取对象y -> 读取CPU缓存2中的y(如果CPU缓存2没有从内存中更新y,b线程y看到过时的数据)
-
instance 指向了对象的内存地址(即instance != null),但instance没调用构造函数,所以其属性是失效的状态。(volatile便可以禁止这样的指令重排序)
new对象cpu的指令是多步的
- 分配内存
- 初始化对象(内存赋值)
- 内存地址赋给instance (instance != null)
但CPU指令可能被优化重排序,3跑到2前面了。假设乱序后
- a线程到3后(之后调2,a线程的执行顺序变成a->3->2),CPU 调度b线程,
- b线程判断 instance != null,调用instance.hello.toString(),
- instance没调用构造函数,hello为null,直接崩溃了。
来个具体的例子
几条happen-before规则:
- 同一个线程中,书写在前面的操作happen-before书写在后面的操作(单线程规则)
- 对锁的unlock操作happen-before后续的对同一个锁的lock操作
- happen-before具有传递性
- 对volatile字段的写操作happen-before后续的对同一个字段的读操作
我们以happen-before的角度看,
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)
}
}
首先需要知道几个事实,
- 语句(5)只会被执行一次,也就是LazySingleton只会存在一个实例
- instance只有两种“曾经可能存在”的值,要么为null,也就是初始值
- getInstance()总是返回非空值,并且每次调用返回相同的引用
这样看来,似乎DCL确实没什么问题,这里的关键是 尽管得到了LazySingleton的正确引用,但是却有可能访问到其成员变量 的 不正确值 ,具体来说LazySingleton.getInstance().getSomeField()有可能返回someField的默认值0
所以,我们只需要说明语句(1)和语句(7)并不存在happen-before关系。
假设线程一是初次调用getInstance()方法,紧接着线程二也调用了getInstance()方法和getSomeField()方法,我们要说明的是线程一的语句(1)并不happen-before线程Ⅱ的语句(7)。
线程二在执行getInstance()方法的语句(2)时,由于对instance的访问并没有处于同步块中,因此线程二可能观察到也可能观察不到线程一在语句(5)时对instance的写入,也就是说instance的值可能为空也可能为非空。
先假设instance的值非空,也就线程二观察到了线程一对instance的写入,这时线程Ⅱ二执行语句(6)直接返回这个instance的值,然后对这个instance调用getSomeField()方法,该方法也是在没有任何同步情况被调用,因此整个线程二的操作都是在没有同步的情况下调用,这时我们无法利用第1条和第2条happen-before规则得到线程一的操作和线程二的操作之间的任何有效的happen-before关系,这说明线程一的语句(1)和线程Ⅱ的语句(7)之间并不存在happen-before关系,这就意味着线程Ⅱ在执行语句(7)完全有可能观测不到线程一在语句(1)处对someFiled写入的值,这就是DCL的问题所在。
很荒谬,是吧?DCL原本是为了逃避同步,它达到了这个目的,也正是因为如此,它最终受到惩罚,这样的程序存在严重的bug,虽然这种bug被发现的概率绝对比中彩票的概率还要低得多,而且是转瞬即逝,更可怕的是,即使发生了你也不会想到是DCL所引起的。
前面我们说了,线程二在执行语句(2)时也有可能观察空值,如果是这种情况,那么它需要进入同步块,并执行语句(4)。在语句(4)处线程二还能够读到instance的空值吗?不可能。这里因为这时对instance的写和读都是发生在同一个锁确定的同步块中,这时读到的数据是最新的数据。线程二在语句(3)处会执行一个lock操作,而线程一在语句(5)后会执行一个unlock操作,这两个操作都是针对同一个锁--LazySingleton.class,因此,线程一的unlock操作happen-before线程二的lock操作,再利用单线程规则,线程一的语句(5) -> 线程一的unlock操作,线程二的lock操作 -> 线程二的语句(4),再根据传递规则,就有线程一的、语句(5) -> 线程二的语句(4),也就是说线程二在执行语句(4)时能够观测到线程一在语句(5)时对LazySingleton的写入值。接着对返回的instance调用getSomeField()方法时,我们也能得到线程Ⅰ的语句(1) -> 线程二的语句(7),这表明这时getSomeField能够得到正确的值。
但是仅仅是这种情况的正确性并不妨碍DCL的不正确性,一个程序的正确性必须在所有的情况下的行为都是正确的,而不能有时正确,有时不正确。对DCL的分析也告诉我们一条经验原则,对引用(包括对象引用和数组引用)的非同步访问,即使得到该引用的最新值,却并不能保证也能得到其成员变量(对数组而言就是每个数组元素)的最新值。
解决
对DCL的分析也告诉我们一条经验原则:对引用(包括对象引用和数组引用)的非同步访问,即使得到该引用的最新值,却并不能保证也能得到其成员变量(对数组而言就是每个数组元素)的最新值。
那么,代码就需要修正,而这个修正很简单,加一个volatile即可
private volatile static LazySingleton instance;
根据这条规则,我们可以得到,线程Ⅰ的语句(5) -> 语线程Ⅱ的句(2),根据单线程规则,线程Ⅰ的语句(1) -> 线程Ⅰ的语句(5)和语线程Ⅱ的句(2) -> 语线程Ⅱ的句(7),再根据传递规则就有线程Ⅰ的语句(1) -> 语线程Ⅱ的句(7),这表示线程Ⅱ能够观察到线程Ⅰ在语句(1)时对someFiled的写入值,程序能够得到正确的行为。
关于final的特殊含义
在java5之前对final字段的同步语义和其它变量没有什么区别,在java5中,final变量一旦在构造函数中设置完成(前提是在构造函数中没有泄露this引用),其它线程必定会看到在构造函数中设置的值。而DCL的问题正好在于看到对象的成员变量的默认值,因此我们可以将LazySingleton的someField变量设置成final,这样在java5中就能够正确运行了。
举个例子:
class FinalFieldExample {
final int x;
int y;
static FinalFieldExample f;
public FinalFieldExample() {
x = 3;
y = 4;
}
static void writer() {
f = new FinalFieldExample();
}
static void reader() {
if (f != null) {
int i = f.x; // guaranteed to see 3
int j = f.y; // could see 0
}
}
}
final修饰对象成员时,可以保证当对象发布时候final已经被赋予构造函数中赋予的值了,如上例中的x,y则可能对象发布时候并未完成初始化。
为何废弃DCL:
DCL产生的原因(无竞争同步的执行速度很慢,以及JVM启动很慢)已经不复存在,因而不是高效的优化措施。
推荐阅读:
https://blog.csdn.net/u014108122/article/details/38352005