A real example of using volatile keyword in Java

[JerryWang]

Consider the following example:

package thread;

public class ThreadVerify {

  public static boolean  stop = false;

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

      Thread testThread = new Thread(){

            @Override

            public void run(){

              int i = 1;

              while(!stop){

               //System.out.println("in thread: " + Thread.currentThread() + " i: " + i);

                  i++;

              }

              System.out.println("Thread stop i="+ i);

           }

         };

         testThread.start();

         Thread.sleep(1000);

         stop = true;

         System.out.println("now, in main thread stop is: " + stop);

         testThread.join();

     }

 }

The working thread is started to do increment on i and after one second, the flag is set as true in main thread. It is expected that we could see print out in working thread: "Thread stop i=". Unfortunately it is NOT the case.

Through process explorer we can find the working thread is still running:

The only way we can terminate it is to click this button in Eclipse:

The reason is: every thread in Java has its own thread local stack in runtime. Every time a thread tries to access the content of a variable, it first locates the variable content in the main memory, then loads this content from main memory to its local stack. Once this load is done, this relationship between thread local stack and main memory is cut.

Later, when thread performs modifications on the variable, the change is directly done on thread local stack. And at a given time ( scheduled by JVM, developer has no control about this timeslot), the change will be refreshed from thread local stack to memory.  Back to our example, already the main thread has changed the flag to true in one second later ( this is TOO late! ), unfortunately when the working thread reads the flag from its own local stack, the flag is still false ( it makes sense since when it is copied from main memory in main thread ), so the working threads could never end. See the following picture for detail.

Solution is: add keyword volatile to flag variable, to force the read access on it in working thread is done always from main memory, so that after the flag is changed to true in main thread, later the working thread can detect this latest change since it reads data from main memory now.

After this keyword is added we can get expected output: