Java volatile 读取可见性保证

Question

我在阅读 JVM 在阅读 volatile 变量时提供的可见性保证时遇到了以下摘录： “当线程 A 写入 volatile 变量并且随后线程 B 读取相同的变量时，在写入 volatile 变量之前对 A 可见的所有变量的值在读取 volatile 变量后对 B 可见。”

我有一个关于 JVM 保证的问题。考虑以下一组类：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        POJO p = new POJO();
        new Th1(p).start();
        new Th2(p).start();
    }
}   
    public class Th1 extends Thread {
        private POJO p1 = null;
        public Th1(POJO obj) {
            p1 = obj;
        }
        @Override
        public void run() {
            p1.a = 10; // t = 1
            p1.b = 10; // t = 2
            p1.c = 10; // t = 5;
            System.out.println("p1.b val: " + p1.b); // t = 8
            System.out.println("Thread Th1 finished"); // t = 9
        }
    }
    
    public class Th2 extends Thread {
        private POJO p2 = null;
        public Th2(POJO obj) {
            p2 = obj;
        }
        @Override
        public void run() {
            p2.a = 30; // t = 3
            p2.b = 30; // t = 4
            int x = p2.c; // t = 6
            System.out.println("p2.b value: " + p2.b); // t = 7
        }
    }
    
    public class POJO {
        int a = 1;
        int b = 1;
        volatile int c = 1;
    }

假设 2 个线程 Th1 和 Th2 在不同的 CPU 中运行，并且它们的指令执行顺序由每行中的注释指示（在它们的运行方法中）。我的问题是： 当代码“int x = p2.c;”在 t = 6 时执行，线程 Th2 可见的变量应根据上述段落从主内存刷新。据我了解，此时主存储器将拥有来自 Th1 的所有写入。变量 p2.b 在 t = 7 打印时会显示什么值？

• p2.b 是否会显示值 10，因为它的值是从读取 volatile 变量 p2.c 中刷新的？
• 或者它会以某种方式保留值 30？

Answer 1

对于您的代码，p2.b 不保证为 10 或 30。写入是竞争条件。

“当线程 A 写入 volatile 变量并且随后线程 B 读取同一变量时，在写入 volatile 变量之前对 A 可见的所有变量的值变得可见读取 volatile 变量后到 B。"

不保证在将 p1.c 写入 Th1 之后完成对 p2.c 的 Th2 读取。

对于您讨论的特定顺序，在 Th2 中读取 p2.c 将不会将 p2.b 的值恢复为 10。

Answer 2

在a 的写入和a 的读取之间没有发生边缘之前。由于它们是相互冲突的操作（其中至少一个是写操作）并且位于同一地址上，因此存在数据争用，因此程序行为未定义。

我认为以下示例更好地解释了您正在寻找的行为：

    public class Test {
        public static void main(String[] args) throws InterruptedException {
            POJO p = new POJO();
            new Th1(p).start();
            new Th2(p).start();
        }
    }   
    
    public class Th1 extends Thread {
        private POJO p1 = null;
        public Th1(POJO obj) {
            p1 = obj;
        }
        @Override
        public void run() {
            a=1;
            b=1;
        }
    }
    
    public class Th2 extends Thread {
        private POJO p2 = null;
        public Th2(POJO obj) {
            p2 = obj;
        }
        @Override
        public void run() {
            if(p.b==1)println("a must be 1, a="+p2.a);
        }
    }
    
    public class POJO {
        int a = 0;
        volatile int b = 0;
    }

a 的写入和b 的写入之间有一个发生在边缘之前（程序顺序规则） 在b 的写入和b 的后续读取之间有一个发生在边缘之前（易失性变量规则） 在b 的读取和a 的读取之间有一个发生在边缘之前（程序顺序规则）

由于happens before 关系是传递的，在a 的写入和a 的读取之间存在一个发生在边缘。所以第二个线程应该会看到来自第一个线程的a=1。