代码如下所示
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
