如果从多个线程访问 Java 中的变量，则必须确保它们被安全地发布。这通常意味着使用synchronized或volatile。
我的印象是，我的一些同事并不认真对待这个问题，因为他们“以前从未听说过volatile，而且他们的程序已经运行了多年”。
所以我的问题是：
谁能提供一个示例 Java 程序/sn-p，它可靠地显示数据可见性问题。
我认为运行一个程序并看到意外的 NPE 或过时的变量值会比仅仅理论上的解释更有帮助，而这无法证明。
非常感谢您的帮助！
更新：再次强调这一点。我已阅读 Java Concurreny in Practice 并且知道理论上存在可见性问题的示例。我正在寻找的是一种真正展示它们的方法。我不确定这实际上是否可行，但也许有一个 jvm 配置或类似的东西允许它。
【问题讨论】：
标签： java multithreading visibility
通过删除操作修改示例here，我想出了一个在我的环境中始终失败的示例（线程永远不会停止运行）。
// Java environment:
// java version "1.6.0_0"
// OpenJDK Runtime Environment (IcedTea6 1.6.1) (6b16-1.6.1-3ubuntu3)
// OpenJDK 64-Bit Server VM (build 14.0-b16, mixed mode)
public class Test2 extends Thread {
boolean keepRunning = true;
public static void main(String[] args) throws InterruptedException {
Test2 t = new Test2();
t.start();
Thread.sleep(1000);
t.keepRunning = false;
System.out.println(System.currentTimeMillis() + ": keepRunning is false");
}
public void run() {
while (keepRunning)
{}
}
}
请注意，此类问题在很大程度上取决于编译器/运行时/系统。特别是编译器可以确定添加指令以从内存中读取变量，即使它不是易失性的——所以代码可以工作——，vm和jit可以优化从内存中读取并只使用寄存器，甚至处理器可以重新排序指令——这不会影响这种情况，但在其他多线程情况下，如果修改了多个变量，它可能会影响来自其他线程的感知状态。
【讨论】：
keepRunning 的更新状态对第二个线程不可见，它将永远运行？我完全错过了什么吗？
强调使用 volatile 重要性的最常见示例是 while(keepRunning) 示例：
public class Test extends Thread {
boolean keepRunning = true;
public static void main(String[] args) throws InterruptedException {
Test t = new Test();
t.start();
Thread.sleep(1000);
t.keepRunning = false;
System.out.println(System.currentTimeMillis() + ": keepRunning is false");
}
public void run() {
while (keepRunning)
System.out.println(System.currentTimeMillis() + ": " + keepRunning);
}
}
由于keepRunning 可能（有效地）保存在运行while 循环的线程的缓存中，因此该程序可能会在keepRunning 设置为false 很久之后为keepRunning 打印“true”。
但是请注意，没有可靠的方法来公开竞争条件。 （请参阅我的其他答案。）此示例可能在某些情况下在硬件/操作系统/jvm 的某些组合上公开它。
【讨论】：
println 并且输出可能是无序的。并发难，主要是因为测试太难了。
谁能提供一个示例 Java 程序/sn-p，可靠地显示数据可见性问题。
不，没有显示数据可见性问题的可靠示例。
原因是程序的任何有效执行 volatile 也是同一程序的有效执行 volatile。 （相反的情况显然不是真的！）
【讨论】：
我有一段代码给你：
package test;
public class LoopTest {
private boolean done = false;
/**
* @param args
*/
public void start() {
System.out.println(System.getProperty("java.vm.name"));
System.out.println(System.getProperty("java.version"));
for (int i = 0; i < 100; i++) {
startNewThread();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
done = true;
System.out.println("forcing end");
}
private void startNewThread() {
new Thread(new Runnable() {
public void run() {
long i = 0;
while(!done) {
i++;
if(i % 100L == 0) {
System.out.println("still working " + i);
}
}
System.out.println("ending " + i);
}
}).start();
}
public static void main(String[] args) {
new LoopTest().start();
}
}
这个以 JVM 服务器模式运行的示例在我的机器上生成了这个输出：
..
..
ending 14100
still working 14800
ending 14800
still working 26500
ending 26500
still working 18200
ending 18200
still working 9400
ending 9400
still working 1300
ending 1300
still working 59500
ending 59500
still working 1700
still working 75400
ending 75400
still working 33500
ending 33500
still working 36100
ending 36100
still working 121000
ending 121000
still working 3000
ending 3000
ending 1700
still working 5900
ending 5900
still working 7800
ending 7800
still working 7800
ending 7800
still working 6800
ending 6800
still working 5300
ending 5300
still working 9100
still working 10600
ending 10600
still working 9600
ending 9600
still working 10000
ending 10000
ending 9100
still working 1700
ending 1700
..
..
看看“结束#”语句：我认为它们都有一个 100 的倍数的数字，这不太可能发生。我的解释是存在可见性问题，导致线程仍然读取 done == false，尽管它已经更新为 true。在使用 "still working #" 语句调用同步的 System.out.println() 方法后，线程读取完成的更新值并退出。
或者有人看到我的代码/解释中有错误吗？
【讨论】：
让他们阅读 Java 并发大师 Brian Goetz 的书Java Concurrency in Practice。对于必须用 Java 编写任何严肃的并发软件的任何人来说，这本书都是必读的！
当然，说“我从未听说过volatile，而且我的程序已经运行多年”是愚蠢的argument from ignorance。
【讨论】：
public class NoVisibility {
private static boolean ready = false;
private static int number;
private static class ReaderThread extends Thread {
@Override
public void run() {
while (!ready) {
Thread.yield();
}
System.out.println(number);
}
}
public static void main(String[] args) throws InterruptedException {
new ReaderThread().start();
number = 42;
Thread.sleep(20000);
ready = true;
}
}
在 20 秒内调用 Thread.sleep() 会发生什么，JIT 将在这 20 秒内启动，它将优化检查并缓存值或完全删除条件。所以代码会在可见性上失败。
要阻止这种情况发生，您必须使用 volatile。
【讨论】：
@David 代码的扩展（配置 Java6 64 位，Eclipse Juno SR2）：
public class NoVisibility_Demonstration extends Thread {
boolean keepRunning = true;
public static void main(String[] args) throws InterruptedException {
NoVisibility_Demonstration t = new NoVisibility_Demonstration();
t.start();
Thread.sleep(1000);
t.keepRunning = false;
System.out.println(System.currentTimeMillis() + ": keepRunning is false");
}
public void run() {
int x = 10;
while (keepRunning)
{
//System.out.println("If you uncomment this line, the code will work without the visibility issue");
x++;
}
System.out.println("x:"+x);
}
}
使用此示例，您可以展示这两种情况。当您在 run() 中取消注释 while 循环中的行时，可见性问题得到解决。原因是 println() 语句使用同步。详细讨论HERE
【讨论】：