缓存刷新Java_java线程缓存刷新什么时候发生？

这在JLS的

Threads and Locks部分中描述.

当需要从主存储器读取线程时,根据同步顺序定义并在订单之前发生.基本上它表示为了使读取产生上次写入的值,写入需要在读取之前发生.

发生在之前的关系粗略地讲是根据锁定/解锁操作定义的(并且有一些例外)归结为同步方法和块的使用.除非您正在处理volatile变量,否则底线通常是您需要同步对共享数据的所有访问,最好是通过AtomicBoolean,BlockingQueue或其他一些java.util.concurrent类.

17.4.4 Synchronization Order

Every execution has a synchronization order. A synchronization order is a total order over all of the synchronization actions of an execution. For each thread t, the synchronization order of the synchronization actions (§17.4.2) in t is consistent with the program order (§17.4.3) of t.

Synchronization actions induce the synchronized-with relation on actions, defined as follows:

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

A write to a volatile variable (§8.3.1.4) v synchronizes-with all subsequent reads of v by any thread (where subsequent is defined according to the synchronization order).

An action that starts a thread synchronizes-with the first action in the thread it starts.

The write of the default value (zero, false or null) to each variable synchronizes-with the first action in every thread. Although it may seem a little strange to write a default value to a variable before the object containing the variable is allocated, conceptually every object is created at the start of the program with its default initialized values.

The final action in a thread T1 synchronizes-with any action in another thread T2 that detects that T1 has terminated. T2 may accomplish this by calling T1.isAlive() or T1.join().

If thread T1 interrupts thread T2, the interrupt by T1 synchronizes-with any point where any other thread (including T2) determines that T2 has been interrupted (by having an InterruptedException thrown or by invoking Thread.interrupted or Thread.isInterrupted).

The source of a synchronizes-with edge is called a release, and the destination is called an acquire.

17.4.5 Happens-before Order

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.

If we have two actions x and y, we write hb(x, y) to indicate that x happens-before y.

If x and y are actions of the same thread and x comes before y in program order, then hb(x, y).

There is a happens-before edge from the end of a constructor of an object to the start of a finalizer (§12.6) for that object.

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

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

It should be noted that the presence of a happens-before relationship between two actions does not necessarily imply that they have to take place in that order in an implementation. If the reordering produces results consistent with a legal execution, it is not illegal.

更新：如果没有发生 – 在关系存在之前,线程永远不需要“刷新其缓存”. This question和它接受的答案提供了一个具体的例子.

以下是已接受答案的略微修改版本：

public class Test {

static boolean keepRunning = true;

public static void main(String[] args) throws InterruptedException {

(new Thread() {

public void run() {

while (keepRunning) {

}

}

}).start();

System.out.println(keepRunning);

Thread.sleep(1000);

keepRunning = false;

System.out.println(keepRunning);

// main thread ends here, but the while-thread keeps running.

// (but not if you change the keepRunning to volatile).

}

}