同步和可见范围

Question

I've been reading up on Java concurrency and had forgot the fact that synchronization blocks in two threads using the same lock also affect the visibility of variables, even though they were not defined as "volatile". If I have code like this

Object lock = new Object();
boolean a = false, b = false, c = false;

void threadOne() {

   a = true;
   synchronized(lock) {
      b = true;
   }
   c = true;

}

void threadTwo() {

   while (true) {
      synchronized(lock) {
         if (a && b && c) break;
      }
   } 

}

... and threadOne and threadTwo will be called by different threads:

1. Is it guaranteed that the code will break out of the while loop?

2. What if we remove variable c out of the equation? I'm wondering if only b is guaranteed to be visible in threadTwo because it was inside the synchronization block.

Answer 1

Is it guaranteed that the code will break out of the while loop?

No. The Java memory model is defined in terms of " happens before " relationships:

Two actions can be ordered by a happens-before relationship. If one action happens-before another, then the first is visible to and ordered before the second.

The spec goes on to say:

If an action x synchronizes-with a following action y, then we also have hb(x, y).

where hb stands for happens-before, and

An unlock action on monitor m synchronizes-with all subsequent lock actions on m (where "subsequent" is defined according to the synchronization order).

Also note that:

If hb(x, y) and hb(y, z), then hb(x, z).

So in your example, the synchronized(lock) around b will establish a happens-before relationship for the following read, and thus the value of b is guaranteed to be visible in other threads that also use synchronized(lock) . Explicitly,

hb(write to b in threadOne, unlock in threadOne) AND 
hb(unlock in threadOne, lock in threadTwo) AND 
hb(lock in threadTwo, read from a in threadTwo) IMPLIES 
hb(write to b in threadOne, read from b in threadTwo) 

Similarly, a will be guaranteed to be visible to the other thread. Explicitly,

hb(write to a in threadOne, lock in threadOne) AND 
hb(lock in threadOne, unlock in threadOne) AND 
hb(unlock in threadOne, lock in threadTwo) AND 
hb(lock in threadTwo, read a in threadTwo) IMPLIES 
hb(write to a in threadOne, read a in threadTwo). 

The write and then subsequent read of c does not have a happens-before relationship, so therefore, according to the spec, the write to c is not necessarily visible to threadTwo .

What if we remove variable c out of the equation? I'm wondering if only b is guaranteed to be visible in threadTwo because it was inside the synchronization block.

Yes, see above.

Answer 2

假设每个线程共享您在问题中定义的（不完整）类的相同实例：

是否保证代码会跳出while循环？

<\/blockquote>

在实践中，是的。锁只在 threadOne 方法中设置 b 的时间很短。 threadTwo 中有足够的上下文切换，以便 threadOne 能够执行同步块。 “在实践中”的含义：在极不可能的情况下（以及实施不佳的 JVM 线程），threadOne 可能会被排除在同步块之外，而 threadTwo 继续为 if 检查重新获取同步锁。<\/em> （事实上​​，我挑战任何人来制作一个 OPs 场景没有完成的工作示例）。

如果我们从方程中删除变量 c 怎么办？我想知道是否只有 b 保证在 threadTwo 中可见，因为它在同步块内。

<\/blockquote>

相同的。在实践中，是的。

对于额外的功劳（挑战），找到一个执行以下代码的 JVM，这样它就不会终止：

 public class SyncTest { public static void main(String args[]) throws Exception { final Shared s = new Shared(); Thread t1 = new Thread () { public void run() { s.threadOne(); } }; Thread t2 = new Thread () { public void run() { s.threadTwo(); } }; t2.start(); t1.start(); } } class Shared { Object lock = new Object(); boolean a = false, b = false, c = false; void threadOne() { a = true; synchronized(lock) { b = true; } c = true; } void threadTwo() { while (true) { synchronized(lock) { if (a && b && c) break; } } } }<\/code><\/pre>"