非易失性字段的发布和读取

Question

public class Factory {
    private Singleton instance;
    public Singleton getInstance() {
        Singleton res = instance;
        if (res == null) {
            synchronized (this) {
                res = instance;
                if (res == null) {
                    res = new Singleton();
                    instance = res;
                }
            }
        }
        return res;
    }
}

它几乎是线程安全的单例的正确实现。我看到的唯一问题是：

初始化实例字段的线程#1可以在完全初始化之前发布。现在，第二个线程可以在不一致的状态下读取实例。

但是，在我看来，这只是问题。这是唯一的问题吗？（并且我们可以使实例不稳定）。

Answer 1

编辑我在这里又写了一个答案，应该可以消除所有的困惑。

这是一个好问题，我在这里试着总结一下我的理解。

假设Thread1当前正在初始化Singleton实例并发布引用（显然不安全）。Thread2可以看到这个不安全的发布引用（意味着它看到一个非空引用），但这并不意味着字段它通过引用（通过构造函数初始化的Singleton字段）也可以正确初始化。

就我所见，之所以会发生这种情况，是因为构造函数中可能会对字段的存储进行重新排序。因为没有“之前发生”的规则（这些都是简单的变量），所以这是完全可能的。

但这并不是唯一的问题。请注意，这里有两种解读：

if (res == null) { // read 1

return res // read 2

这些读取没有同步保护，因此它们是快速读取。AFAIK这意味着read 1可以读取非空引用，而read 2可以读取空引用。

顺便说一句，这和全能的希皮尔耶夫解释的是一样的（即使我读了这篇文章1/2年，我仍然每次都能找到新的东西）。

事实上，让实例变得不稳定将解决问题。当你让它变得不稳定时，就会发生这种情况：

 instance = res; // volatile write, thus [LoadStore][StoreStore] barriers

所有“其他”操作（来自构造函数内的存储）都不能通过此界限，不会重新排序。这还意味着，当您读取volatile变量并看到一个非空值时，这意味着在写入volatile之前所做的每一次“写入”都确实发生了。这篇优秀的帖子有它的确切含义

这也解决了第二个问题，因为这些操作不能被重新排序，所以保证从read 1和read 2中看到相同的值。

无论我读了多少书，并试图理解这些东西对我来说总是很复杂，我所认识的人中很少有人能够编写这样的代码，并正确地对此进行推理。当你可以的时候（我愿意！）请坚持使用已知和有效的双重检查锁定示例：）

Answer 2

通常情况下，我再也不会使用双重检查锁定机制了。要创建线程安全的单例，您应该让编译器执行以下操作：

public class Factory {
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return res;
    }
}

现在您正在使实例变得不稳定。我认为这个解决方案没有必要，因为jit编译器现在在构造对象时处理线程的同步。但是如果你想让它变得不稳定，你可以。

最后，我将使getInstance（）和实例保持静态。然后你可以参考工厂。直接获取实例（），而不构造工厂类。另外：应用程序中的所有线程都将获得相同的实例。否则每个新工厂（）都会给你一个新实例。

你也可以看看维基百科。如果你需要一个懒惰的解决方案，他们有一个干净的解决方案：

https://en.wikipedia.org/wiki/Double-checked_locking#Usage_in_Java

// Correct lazy initialization in Java
class Foo {
    private static class HelperHolder {
       public static final Helper helper = new Helper();
    }

    public static Helper getHelper() {
        return HelperHolder.helper;
    }
}

Answer 3

ShiPilev在Java的安全发布和安全初始化中解释了您的示例。我强烈建议阅读整篇文章，但是要总结一下，请查看那里的UnsecLocalDCLFactory部分：

public class UnsafeLocalDCLFactory implements Factory {
  private Singleton instance; // deliberately non-volatile

  @Override
  public Singleton getInstance() {
    Singleton res = instance;
    if (res == null) {
      synchronized (this) {
        res = instance;
        if (res == null) {
           res = new Singleton();
           instance = res;
        }
      }
    }
    return res;
  }
}

以上问题如下：

在这里引入局部变量是一个正确性修正，但只是部分修正：在发布Singleton实例和读取它的任何字段之间，之前仍然没有发生任何事情。我们只是保护自己不返回“null”而不是单例实例。同样的技巧也可以被视为SafeDCLFactory的性能优化，即只进行一次易失性读取，产生：

ShiPilev建议通过标记实例来修复如下问题：

public class SafeLocalDCLFactory implements Factory {
  private volatile Singleton instance;

  @Override
  public Singleton getInstance() {
    Singleton res = instance;
    if (res == null) {
      synchronized (this) {
        res = instance;
        if (res == null) {
          res = new Singleton();
          instance = res;
        }
      }
    }
    return res;
  }
}

这个例子没有其他问题。