Styjun

In JSR-133 section 3.1, which discusses the visibility of actions between threads - it is mentioned that the code example below, which does not utilise the volatile keyword for the boolean field, can become an infinite loop if two threads are running it. Here is the code from the JSR:

class LoopMayNeverEnd 
 boolean done = false;
 void work() 
 while (!done) 
 // do work
 
 
 void stopWork() 
 done = true;
 

Here is a quote of the important bit in that section that I'm interested in:

... Now imagine that two threads are created, and that one
thread calls work(), and at some point, the other thread calls stopWork(). Because there is
no happens-before relationship between the two threads, the thread in the loop may never
see the update to done performed by the other thread ...

And here is my own Java code I wrote just so I can see it loop:

public class VolatileTest 
 private boolean done = false;
 public static void main(String[] args) 
 VolatileTest volatileTest = new VolatileTest();
 volatileTest.runTest();
 
 private void runTest() 
 Thread t1 = new Thread(() -> work());
 Thread t2 = new Thread(() -> stopWork());
 t1.start();
 t2.start();
 
 private void stopWork() 
 done = true;
 System.out.println("stopped work");
 
 private void work() 
 while(!done)
 System.out.println("started work");
 
 

Although the results from consecutive executions are different - as expected - I don't see it ever going into an infinite loop. I'm trying to understand how I can simulate the infinite loop that the documentation suggests, what am I missing? How does declaring the boolean volatile, remove the infinite loop?

The actual behavior is OS and JVM specific. For example, by default, Java runs in client mode on 32-bit Windows and in server mode on the Mac. In client mode the work method will terminate, but will not terminate in server mode.

This happens because of the Java server JIT compiler optimization. The JIT compiler may optimize the while loop, because it does not see the variable done changing within the context of the thread. Another reason of the infinite loop might be because one thread may end up reading the value of the flag from its registers or cache instead of going to memory. As a result, it may never see the change made by the another thread to this flag.

Essentially by adding volatile you make the thread owning done flag to not cache this flag. Thus, the boolean value is stored in common memory and therefore guarantees visibility. Also, by using volatile you disabling JIT optimization that can inline the flag value.

Basically if you want to reproduce infinite loop - just run your program in server mode:

java -server VolatileTest