为什么在双重检查锁定中使用volatile

Question

从Head First设计模式一书中，具有双重检查锁定的单例模式已实现如下：

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

我不明白为什么要使用 volatile。 volatile 的使用不会破坏使用双重检查锁定的目的，即性能吗？

Answer 1

了解为什么需要volatile 的一个很好的资源来自JCIP 书。维基百科也有该材料的decent explanation。

真正的问题是Thread A 可能会在instance 完成构造instance 之前为其分配内存空间。 Thread B 将看到该分配并尝试使用它。这会导致Thread B 失败，因为它使用的是instance 的部分构造版本。

Answer 2

正如@irreputable 所引用的，易失性并不昂贵。即使代价高昂，一致性也应优先于性能。

对于 Lazy Singletons，还有一种更简洁优雅的方式。

public final class Singleton {
    private Singleton() {}
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

来源文章：Initialization-on-demand_holder_idiom来自维基百科

在软件工程中，Initialization on Demand Holder（设计模式）习语是延迟加载的单例。在所有 Java 版本中，该习惯用法都可以实现安全、高并发的延迟初始化，并具有良好的性能

由于该类没有任何要初始化的static 变量，因此初始化很容易完成。

其中的静态类定义LazyHolder在JVM确定必须执行LazyHolder之前不会初始化。

静态类LazyHolder仅在类Singleton上调用静态方法getInstance时执行，第一次发生这种情况时，JVM将加载并初始化LazyHolder类。

此解决方案是线程安全的，不需要特殊的语言结构（即volatile 或synchronized）。

Answer 3

嗯，没有双重检查锁定性能。这是一个破碎的模式。

抛开情绪不谈，volatile 就在这里，因为如果没有它，当第二个线程通过 instance == null 时，第一个线程可能还不能构造 new Singleton()：没有人保证对象的创​​建 发生之前 为任何线程分配instance，但实际创建对象的线程除外。

volatile 反过来在读写之间建立 happens-before 关系，并修复损坏的模式。

如果您正在寻找性能，请改用 holder 内部静态类。

Answer 4

将变量声明为volatile 可以保证对它的所有访问实际上都是从内存中读取其当前值。

如果没有volatile，编译器可能会优化对变量的内存访问（例如将其值保存在寄存器中），因此只有第一次使用变量时才会读取保存变量的实际内存位置。如果变量在第一次和第二次访问之间被另一个线程修改，这是一个问题；第一个线程只有第一个（修改前）值的副本，因此第二个if 语句测试变量值的旧副本。

Answer 5

如果你没有它，第二个线程可以在第一个设置为 null 之后进入同步块，你的本地缓存仍然会认为它是 null。

第一个不是为了正确（如果你是正确的，那就是自我挫败），而是为了优化。

Answer 6

易失性读取本身并不昂贵。

您可以设计一个测试以在紧密循环中调用getInstance()，以观察易失性读取的影响；然而，这种测试是不现实的；在这种情况下，程序员通常会调用一次getInstance()，并在使用期间缓存实例。

另一个实现是使用final 字段（参见维基百科）。这需要额外的读取，这可能比volatile 版本更昂贵。 final 版本在紧密循环中可能会更快，但如前所述，该测试没有实际意义。

Answer 7

双重检查锁定是一种在多线程环境中调用getInstance方法时防止创建另一个单例实例的技术。

注意

• 在初始化之前会检查两次单例实例。
• 为了提高性能，仅在首次检查单例实例后才使用同步临界区。
• volatile 实例成员声明中的关键字。这将告诉编译器始终读取和写入主内存而不是 CPU 缓存。使用volatile 变量保证happens-before 关系，所有的写入都将发生在实例变量的任何读取之前。

缺点

• 由于它需要volatile 关键字才能正常工作，因此它与Java 1.4 及更低版本不兼容。问题是乱序写入可能允许在执行单例构造函数之前返回实例引用。
• volatile 变量的拒绝缓存导致性能问题。
• 在初始化之前会检查两次单例实例。
• 它非常冗长，使代码难以阅读。

单例模式有多种实现方式，各有优缺点。

• 渴望加载单例
• 双重检查锁定单例
• Initialization-on-demand 持有者习语
• 基于枚举的单例

每一个的详细描述都太冗长了，所以我只是放了一篇好文章的链接-All you want to know about Singleton