Java内存模型同步：如何诱发数据可见性bug？

Question

“Java 并发实践”给出了以下不安全类的示例，由于 java 内存模型的性质，该类可能会永远运行或打印 0。

该类试图演示的问题是这里的变量不是“共享的”线程之间。因此，线程看到的值可能与另一个线程不同，因为它们不是易失性或同步的。另外，由于 JVM 允许对语句进行重新排序，ready=true 可能会在 number=42 之前设置。

对我来说，这个类在使用 JVM 1.6 时总是工作得很好。关于如何让此类执行不正确的行为（即打印 0 或永远运行）有什么想法吗？

public class NoVisibility {
    private static boolean ready;
    private static int number;

    private static class ReaderThread extends Thread {
        public void run() {
            while (!ready)
                Thread.yield();
            System.out.println(number);
        }
    }

    public static void main(String[] args) {
        new ReaderThread().start();
        number = 42;
        ready = true;
    }
}

Answer 1

您遇到的问题是您没有等待足够长的时间来优化代码和缓存值。

当 x86_64 系统上的线程第一次读取值时，它会获得一个线程安全副本。只有后来的变化它才能看不到。在其他 CPU 上可能不会出现这种情况。

如果您尝试这样做，您会发现每个线程都停留在其本地值上。

public class RequiresVolatileMain {
    static volatile boolean value;

    public static void main(String... args) {
        new Thread(new MyRunnable(true), "Sets true").start();
        new Thread(new MyRunnable(false), "Sets false").start();
    }

    private static class MyRunnable implements Runnable {
        private final boolean target;

        private MyRunnable(boolean target) {
            this.target = target;
        }

        @Override
        public void run() {
            int count = 0;
            boolean logged = false;
            while (true) {
                if (value != target) {
                    value = target;
                    count = 0;
                    if (!logged)
                        System.out.println(Thread.currentThread().getName() + ": reset value=" + value);
                } else if (++count % 1000000000 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": value=" + value + " target=" + target);
                    logged = true;
                }
            }
        }
    }
}

打印以下内容，显示其翻转值，但卡住了。

Sets true: reset value=true
Sets false: reset value=false
...
Sets true: reset value=true
Sets false: reset value=false
Sets true: value=false target=true
Sets false: value=true target=false
....
Sets true: value=false target=true
Sets false: value=true target=false

的时间

1705    1 % RequiresVolatileMain$MyRunnable::run @ -2 (129 bytes)   made not entrant
1705    2 % RequiresVolatileMain$MyRunnable::run @ 4 (129 bytes)

如果我添加 -XX:+PrintCompilation 这个切换发生在您看到这表明代码已编译为本机是一种非线程安全的方式

。如果你将值设置为易失性，你会看到它无休止地翻转该值（或者直到我感到无聊）

编辑：这个测试的作用是；当它检测到该值不是该线程的目标值时，它会设置该值。 IE。线程 0 设置为 true，线程 1 设置为 false 当两个线程正确共享该字段时，它们会看到彼此的变化，并且该值不断在 true 和 false 之间翻转。

如果没有 挥发性，这将失败，并且每个线程只能看到自己的值，因此它们都更改值，并且对于同一字段，线程 0 看到 true ，线程 1 看到 false 。

Answer 2

Java 内存模型定义了工作所需的内容和不需要的内容。不安全多线程代码的“美妙之处”在于，在大多数情况下（特别是在受控开发环境中）它通常可以工作。只有当您使用更好的计算机投入生产并且负载增加并且 JIT 真正发挥作用时，错误才会开始出现。

Answer 3

对此不是100%确定，但是这个< /a> 可能相关：

重新排序是什么意思？

在很多情况下都需要访问程序变量
（对象实例字段、类静态字段和数组元素）可以
执行顺序似乎与指定的顺序不同
程序。编译器可以自由地调整顺序
以优化的名义进行说明。处理器可以执行
在某些情况下指令会乱序。数据可能是
在寄存器、处理器高速缓存和主存之间移动
与程序指定的顺序不同。

例如，如果一个线程写入字段 a，然后写入字段 b，并且
b 的值不依赖于 a 的值，那么编译器是
可以自由地重新排序这些操作，并且缓存可以自由地将 b 刷新到
a. 之前的主存储器有许多潜在的来源
重新排序，例如编译器、JIT 和缓存。

编译器、运行时和硬件应该共同创建
仿佛串行语义的错觉，这意味着在
单线程程序，程序不应该能够观察到
重新排序的影响。然而，重新排序可以发挥作用
错误同步的多线程程序，其中一个线程是
能够观察其他线程的效果，并且也许能够
检测变量访问对 a 中的其他线程可见
与程序中执行或指定的顺序不同。

Answer 4

我认为主要的一点是，不能保证所有 jvm 都会以相同的方式重新排序指令。作为示例，存在不同的可能的重新排序，因此对于 jvm 的某些实现，您可能会得到不同的结果。碰巧您的 jvm 每次都以相同的方式重新排序，但其他 jvm 可能并非如此。保证排序的唯一方法是使用正确的同步。

Answer 5

根据您的操作系统，Thread.yield() 可能会也可能不会工作。
Thread.yield() 不能真正被视为独立于平台，如果您需要这种假设，则不应使用它。

让这个例子做你期望它做的事情，我认为这更多的是处理器架构的问题……尝试在不同的机器上运行它，使用不同的操作系统，看看你能从中得到什么。

Answer 6

请看下面的代码，它引入了 x86 上的数据可见性错误。
尝试过jdk8和jdk7

package com.snippets;


public class SharedVariable {

    private static int  sharedVariable = 0;// declare as volatile to make it work
    public static void main(String[] args) throws InterruptedException {

        new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sharedVariable = 1;
            }
        }).start();

        for(int i=0;i<1000;i++) {
            for(;;) {
                if(sharedVariable == 1) {
                    break;
                }
            }
        }
        System.out.println("Value of SharedVariable : " + sharedVariable);
    }

}

技巧是不要期望处理器进行重新排序，而是让
编译器进行一些优化，从而引入可见性错误。

如果运行上面的代码，您将看到它无限期地挂起，因为它永远看不到更新的值sharedVariable。

要更正代码，请将共享变量声明为易失性。

为什么普通变量不起作用并且上面的程序挂起？

1. SharedVariable 未声明为 volatile。
2. 现在，因为sharedVariable没有声明为易失性编译器优化了代码。
   它看到sharedVariable不会被改变所以为什么我应该阅读
   每次循环时都从内存中。它将把sharedVariable带出循环。类似于下面的东西。

f

for(int i=0;i<1000;i++)/**compiler reorders sharedVariable
as it is not declared as volatile
and takes out the if condition out of the loop
which is valid as compiler figures out that it not gonna  
change sharedVariable is not going change **/
    if(sharedVariable != 1) {  
     for(;;) {}  
    }      
}

在 github 上共享： https://github。 com/lazysun/concurrency/blob/master/Concurrency/src/com/snippets/SharedVariable.java