为什么双重检查锁定中使用易失性

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

我不明白为什么使用易失性。难道易失性的使用会破坏使用双重检查锁定即性能的目的吗？

Answer 1

JCIP 书中有一个很好的资源可以帮助您理解为什么需要 volatile。维基百科也对该材料有体面的解释。

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

Answer 2

正如 @irreputable 所引用的， volatile 并不昂贵。即使价格昂贵，一致性也应该优先于性能。

对于懒惰单例来说，还有一种更干净优雅的方式。

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 来自维基百科

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

由于该类没有任何要初始化的静态变量，因此初始化可以轻松完成。

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

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

该解决方案是线程安全的，不需要特殊的语言结构（即易失性或同步）。

Answer 3

好吧，没有双重检查锁定来提高性能。这是一个破损的模式。

抛开情绪不谈，易失性在这里是因为如果没有它，当第二个线程传递instance == null时，第一个线程可能无法构造new Singleton() > 然而：除了实际创建对象的线程之外，没有人承诺对象的创建发生在分配给任何线程的实例之前。

易失性反过来在读取和写入之间建立发生之前关系，并修复损坏的模式。

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

Answer 4

之所以需要易失性是因为易失性

• 在线程之间的Java变量可见性
• 中有2种语义停止重新排序

所以在双重检查锁中没有易失性的问题是语句

< code>instance = new Singleton()

字节码主要有3个步骤，可以通过命令查看 javap -c Singleton.class

      17: new           #3                  // class Singleton
      20: dup
      21: invokespecial #4                  // Method "<init>":()V

1. 为对象分配内存空间（尚未初始化）
2. 创建一个变量指向该空间内存地址
3. 调用构造函数来初始化对象

这 3 个步骤可以在运行时由 CPU 或 JVM 重新排序，在这种情况下，您可能会得到尚未完全初始化的实例。

通过使用易失性，JVM将插入monitorenter和monitorexit以避免如下重新排序。

      10: monitorenter
      11: getstatic     #2                  // Field instance:LSingleton;
      14: ifnonnull     27
      17: new           #3                  // class Singleton
      20: dup
      21: invokespecial #4                  // Method "<init>":()V
      24: putstatic     #2                  // Field instance:LSingleton;
      27: aload_0
      28: monitorexit

所以单例需要volative。

Answer 5

如果您没有它，则在第一个线程将其设置为 null 后，第二个线程可能会进入同步块，并且您的本地缓存仍会认为它为 null。

第一个不是为了正确性（如果你是正确的那就会弄巧成拙），而是为了优化。

Answer 6

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

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

Answer 7

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

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

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

Answer 8

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

注意

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

缺点

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

单例模式有多种实现，每一种都有优点和缺点。

• 热切加载单例
• 双重检查锁定单例
• 按需初始化持有者习语
• 基于枚举的单例

详细描述 他们每个人都太冗长了，所以我只是放了一个好文章的链接 - 有关 Singleton 的所有信息