没有 volatile 的双重检查锁是错误的？

Question

我使用 jdk1.8。 我认为没有 volatile 的双重检查锁是正确的。 我多次使用 countdownlatch 测试，对象是单例。 如何证明它一定需要“volatile”？

更新 1

抱歉，我的代码没有格式化，因为我无法接收一些 JavaScript 公共类 DCLTest {

private static /*volatile*/ Singleton instance = null;

static class Singleton {

    public String name;

    public Singleton(String name) {
        try {
            //We can delete this sentence, just to simulate various situations
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.name = name;
    }
}

public static Singleton getInstance() {
    if (null == instance) {
        synchronized (Singleton.class) {
            if (null == instance) {
                instance = new Singleton(Thread.currentThread().getName());
            }
        }
    }
    return instance;
}

public static void test() throws InterruptedException {
    int count = 1;
    while (true){
        int size = 5000;
        final String[] strs = new String[size];
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < size; i++) {
            final int index = i;
            new Thread(()->{
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Singleton instance = getInstance();
                strs[index] = instance.name;
            }).start();
        }
        Thread.sleep(100);
        countDownLatch.countDown();
        Thread.sleep(1000);
        for (int i = 0; i < size-1; i++) {
            if(!(strs[i].equals(strs[i+1]))){
                System.out.println("i = " + strs[i] + ",i+1 = "+strs[i+1]);
                System.out.println("need volatile");
                return;
            }
        }
        System.out.println(count++ + " times");
    }
}

public static void main(String[] args) throws InterruptedException {
    test();
}

}

Answer 1

您没有看到的关键问题是指令可以重新排序。 因此，它们在源代码中的顺序与它们在内存中的应用顺序不同。 CPU 和编译器是原因或这种重新排序。

我不会详细介绍双重检查锁定示例的整个示例，因为有很多示例可用，但将为您提供足够的信息来进行更多研究。

如果您有以下代码：

 if(singleton == null){
     synchronized{
         if(singleton == null){
            singleton = new Singleton("foobar")
         }
     }
 }

然后在引擎盖下会发生这样的事情。

if(singleton == null){
     synchronized{
         if(singleton == null){
            tmp = alloc(Singleton.class)
            tmp.value = "foobar"
            singleton = tmp
         }
     }
 }

到目前为止，一切都很好。 但以下重新排序是合法的：

if(singleton == null){
     synchronized{
         if(singleton == null){
            tmp = alloc(Singleton.class)
            singleton = tmp
            tmp.value = "foobar"
         }
     }
 }

所以这意味着尚未完全构造的单例（尚未设置值）已写入单例全局变量。 如果一个不同的线程读取这个变量，它可以看到一个部分创建的对象。

还有其他潜在的问题，如原子性（例如，如果值字段很长，它可能会被碎片化，例如读/写撕裂）。 还有可见性； 例如，编译器可以优化代码，以便优化内存中的加载/存储。 请记住，从内存而不是缓存中读取的思考从根本上是有缺陷的，也是我在 SO 上看到的最常遇到的误解； 甚至很多前辈都弄错了。 原子性、可见性和重新排序是 Java 内存模型的一部分，并且使单例变量可变，解决了所有这些问题。 它消除了数据竞争（您可以查找它以获取更多详细信息）。

如果你想成为真正的核心，在创建对象和分配给单例之间放置一个 [storestore] 屏障就足够了，在读取端放置一个 [loadload] 屏障就足够了。 但这远远超出了大多数工程师的理解，并且在大多数情况下不会对性能产生太大影响。

如果您想检查某些东西是否会损坏，请查看 JCStress：

https://github.com/openjdk/jcstress

它是一个很棒的工具，可以帮助您证明您的代码已损坏。

Answer 2

如何证明它一定需要“volatile”？

作为一般规则，您无法通过测试来证明多线程应用程序的正确性。 您也许能够证明不正确，但即使如此也不能保证。 正如你在观察。

您没有成功地使您的应用程序失败的事实并不能证明它是正确的。

证明正确性的方法是在分析之前进行形式化（即数学）。

可以很直接地表明，当singleton不是volatile ，在执行之前会发生缺失。 这可能会导致不正确的结果，例如多次进行初始化。 但不能保证您会得到不正确的结果。

另一方面是，如果使用volatile ，则发生在关系与代码逻辑相结合之前发生的事情足以构建正式（数学）证明，您将始终得到正确的结果。

---

（我不打算在这里构造证明。太费力了。）