【发布时间】：2012-03-06 09:03:27
【问题描述】：
我有一个 Thread-X，它每秒读取一个 非易失性 变量，这样做没有任何同步手段。
现在我想知道是否有某种方法可以修改 Thread-Y 上的非易失性变量，以便 Thread-Y 的写入（最终）在 Thread-X 上可见？
public class Test {
private static boolean double = 1; // this variable is
// strictly not volatile
public static void main(String args[]) {
new java.lang.Thread(new java.lang.Runnable() {
@Override
public void run() {
while (true) {
System.out.println(variable);
try {
java.lang.Thread.currentThread().sleep(1000);
} catch (java.lang.InterruptedException e) {
}
}
}
}).start(); // line 17
new java.lang.Thread(new java.lang.Runnable() {
@Override
public void run() {
// the task is to change variable to "2" such the write
// is (eventually) registered by the other threads
// allowed to use any synchronization/locking techniques
// required, but line 1 to line 17 must not be changed
}
}).start();
}
}
是否可以修改非易失性变量，使另一个没有任何同步技术（raw read）读取它的线程最终能够“看到”更新？
背景：
我需要从大量线程中读取一个变量无限次。
据我了解（如果我错了，请纠正我），在大多数 cpu（例如 x86）上，对 volatile 变量的读取“几乎完全免费”但不是“完全免费”。
现在，由于我从 infinite 数量的线程中有 infinite 数量的读取，我希望该变量是 non-volatile .但是，一旦出现蓝月亮，就需要更新变量。在我的用例中，更新该变量的成本实际上并不重要，但该更新最终必须由读取器线程读取。
解决方案：
基于Tomasz's comment，我构建了这个解决方案，我想知道解决方案1 有缺陷还是可靠？
public class Solution1 {
private static double variable = 1; // this variable is
// strictly not volatile
public static void main(String args[]) {
new java.lang.Thread(new java.lang.Runnable() {
@Override
public void run() {
while (true) {
System.out.println(variable);
try {
java.lang.Thread.currentThread().sleep(1000);
} catch (java.lang.InterruptedException e) {
}
}
}
}).start(); // line 17
new java.lang.Thread(new java.lang.Runnable() {
@Override
public void run() {
variable = 2;
// writer-thread now terminates,
// is it guaranteed that when it
// "terminates successfully", variable
// is updated on the reader-thread ?
}
}).start();
}
}
基于Joonas's comment，我构建了这个解决方案，我想知道解决方案2 有缺陷还是可靠？
public class Solution2 {
private static double variable = 1; // this variable is
// strictly not volatile
private static volatile boolean lock = false;
public static void main(String args[]) {
new java.lang.Thread(new java.lang.Runnable() {
@Override
public void run() {
while (true) {
System.out.println(variable);
try {
java.lang.Thread.currentThread().sleep(1000);
} catch (java.lang.InterruptedException e) {
}
}
}
}).start(); // line 17
new java.lang.Thread(new java.lang.Runnable() {
@Override
public void run() {
variable = 2;
lock = false; // does this line guarantee
// that other threads will now
// see the update to variable (piggypacking)?
// now let's assume this thread doesn't terminate
}
}).start();
}
}
【问题讨论】：
-
您可以使变量易变。这就是它的用途。此外，轮询通常不是一个糟糕的解决方案，也许还有比轮询更干净的替代方案。
-
@DavidHeffernan 我正在使用民意调查来证明这个问题..因为没有一个例子很难清楚地解释它。
标签： java synchronization