如何避免在单例模式中使用 volatile 的性能开销？

Question

单例模式的代码：

class Singleton 
{ 
    private volatile static Singleton obj; 

    private Singleton() {} 

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

上面代码中的obj被标记为Volatile，这意味着每当在代码中使用obj时，它总是从主内存中获取，而不是使用缓存的值。因此，每当需要执行if(obj==null) 时，它都会从主内存中获取 obj，尽管它的值是在上一次运行中设置的。这是使用 volatile 关键字的性能开销。我们如何避免它？

Answer 1

您严重误解了 volatile 所做的事情，但公平地说，互联网和 stackoverflow 包括只是被错误或不完整的答案所污染。我也承认我认为我对它有很好的把握，但有时不得不重新阅读一些东西。

您所展示的 - 称为“双重检查锁定”习语，它是创建单例的完全有效的用例。问题是您是否真的需要它（另一个答案显示了一种更简单的方法，或者如果您愿意，您也可以阅读“枚举单例模式”）。有多少人知道这个成语需要volatile，但不能真正告诉为什么需要它。

DCL 主要做两件事 - 确保原子性（多个线程不能同时进入同步块）并确保一旦创建，所有线程都会看到创建的实例，称为可见性。同时，它保证了同步块会一次进入，之后的所有线程都不需要这样做。

您可以通过以下方式轻松完成：

  private Singleton instance;

  public Singleton get() {
    synchronized (this) {
      if (instance == null) {
        instance = new Singleton();
      }
      return instance;
    }
  }

但是现在每个需要instance 的线程都必须竞争锁并且必须进入那个同步块。

有些人认为：“嘿，我可以解决这个问题！”并写入（因此只进入同步块一次）：

  private Singleton instance; // no volatile

  public Singleton get() {
    if (instance == null) {  
      synchronized (this) {
        if (instance == null) { 
          instance = new Singleton();
        }
      }
    }
    return instance; 
  }

就这么简单——那就是坏了。这并不容易解释。

• 因为instance 有两个独立读取而被破坏； JMM 允许对这些进行重新排序；因此，if (instance == null) 看不到空值是完全有效的；而return instance; 看到并返回null。是的，这违反直觉，但完全有效且可证明（我可以在 15 分钟内编写 jcstress 测试来证明这一点）。

• 第二点有点棘手。假设你的单例有一个需要设置的字段。

看这个例子：

static class Singleton {

    private Object some;

    public Object getSome() {
        return some;
    }

    public void setSome(Object some) {
        this.some = some;
    }
}

您编写这样的代码来提供该单例：

private Singleton instance;

public Singleton get() {
    if (instance == null) {  
        synchronized (this) {
            if (instance == null) { 
                instance = new Singleton();
                instance.setSome(new Object());
            }
        }
    }
    return instance; 
}

由于写入到volatile（instance = new Singleton();）发生之前设置您需要instance.setSome(new Object());的字段；读取此实例的某些线程可能会看到 instance 不为空，但在执行 instance.getSome() 时会看到空值。正确的做法是（加上创建实例volatile）：

 public Singleton get() {
    if (instance == null) {
        synchronized (this) {
            if (instance == null) {
                Singleton copy = new Singleton();
                copy.setSome(new Object());
                instance = copy;
            }
        }
    }
    return instance; 
}

因此volatile需要安全发布；这样所有线程都可以“安全地”看到已发布的引用-它的所有字段都已初始化。还有一些其他方法可以安全地发布引用，例如在构造函数中设置final 等。

事实：读取比写入便宜；只要您的代码正确，您就不应该关心volatile 读取的内容；所以不要担心“从主内存读取”（或者最好不要在没有部分理解的情况下使用这个短语）。

Answer 2

如果你想避免使用volatile，那么你可以在类加载时初始化，使用私有构造函数来避免创建新的实例。

public class Singleton{
    //Initialized when class loading
    private static final Singleton INSTANCE = new Singleton();

    //To avoid creating new instance of Singleton
    private Singleton(){}

    public static Singleton getSingleton(){
        return INSTANCE;
    }
}

Answer 3

您可以使用Lazy initialization with Holder static class

class Singleton 
{ 

    private Singleton() {} 

    private static class LazyLoader{ 
        static final Singleton obj = new Singleton();
    }

    public static Singleton getInstance() 
    { 
        return LazyLoader.obj;
    } 
} 

这里要注意的重要一点是构造函数应该是故障安全的，否则类加载器会抛出NoClassDefFoundError

Answer 4

你应该使用枚举来实现单例。

Joshua Bloch 建议使用 Enum 来实现 Singleton 设计模式，因为 Java 将确保任何枚举值在 Java 中只实例化一次 程序。缺点是枚举类型有些不灵活；为了 例如，它不允许延迟初始化。

public enum EnumSingleton {
    INSTANCE;
    int value;
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}

public class EnumDemo {
    public static void main(String[] args) {
        EnumSingleton singleton = EnumSingleton.INSTANCE;
        System.out.println(singleton.getValue());
        singleton.setValue(2);
        System.out.println(singleton.getValue());
    }
}

这篇文章很好地列出了使用枚举的其他好处： java singleton instantiation