了解 Java 易失性可见性

本文介绍了了解 Java 易失性可见性的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我正在阅读 Java volatile 关键字，但对其可见性"感到困惑.

I'm reading about the Java volatile keyword and have confusion about its 'visibility'.

volatile 关键字的典型用法是:

A typical usage of volatile keyword is:

volatile boolean ready = false;
int value = 0;

void publisher() {
    value = 5;
    ready = true;
}

void subscriber() {
    while (!ready) {}
    System.out.println(value);
}

正如大多数教程所解释的，对 ready 使用 volatile 可确保:

As explained by most tutorials, using volatile for ready makes sure that:

在发布者线程上更改为 ready 对其他线程(订阅者)立即可见；
当 ready 的变化对其他线程可见时，ready 之前的任何变量更新(这里是 value 的变化)是也对其他线程可见；

change to ready on publisher thread is immediately visible to other threads (subscriber);
when ready's change is visible to other thread, any variable update preceding to ready (here is value's change) is also visible to other threads;

我理解第二点，因为volatile变量通过使用内存屏障来防止内存重新排序，所以在volatile写之前的写入不能在它之后重新排序，而在volatile读之后的读取不能在它之前重新排序.这就是 ready 如何防止在上面的演示中打印 value = 0.

I understand the 2nd, because volatile variable prevents memory reordering by using memory barriers, so writes before volatile write cannot be reordered after it, and reads after volatile read cannot be reordered before it. This is how ready prevents printing value = 0 in the above demo.

但我对第一个保证感到困惑，即 volatile 变量本身的可见性.对我来说，这听起来是一个非常模糊的定义.

But I have confusion about the 1st guarantee, which is visibility of the volatile variable itself. That sounds a very vague definition to me.

换句话说，我的困惑在于单个变量的可见性，而不是多个变量的重新排序或其他什么.让我们简化上面的例子:

In other words, my confusion is just on SINGLE variable's visibility, not multiple variables' reordering or something. Let's simplify the above example:

volatile boolean ready = false;

void publisher() {
    ready = true;
}

void subscriber() {
    while (!ready) {}
}

如果 ready 没有被定义为 volatile，那么订阅者是否有可能无限地卡在 while 循环中?为什么?

If ready is not defined volatile, is it possible that subscriber get stuck infinitely in the while loop? Why?

我想问的几个问题:

立即可见"是什么意思?写操作需要一些时间，那么其他线程多久能看到 volatile 的变化呢?在写入开始后不久但在写入完成之前发生的另一个线程中的读取能否看到更改?
对于现代 CPU 来说，可见性是由缓存一致性协议(例如 MESI)保证的，那么 volatile 在这里有什么帮助?
有些文章说 volatile 变量直接使用内存而不是 CPU 缓存，这保证了线程之间的可见性.这听起来并不正确.

   Time : ---------------------------------------------------------->

 writer : --------- | write | -----------------------
reader1 : ------------- | read | -------------------- can I see the change?
reader2 : --------------------| read | -------------- can I see the change?

希望我清楚地解释了我的问题.

Hope I explained my question clearly.

了解

了解 Java 易失性可见性

问题描述

推荐答案