Is the Volatile modifier required here?

[Nikhil Sun]

I know that global variables are shared between threads.

Consider the below code:

public class Terminate
{
   public static void main (String [] args)
   {
      ThreadB tb = new ThreadB ();
      ThreadA ta = new ThreadA (tb);
      tb.start ();
      ta.start ();
   }
}
class ThreadA extends Thread
{
   private ThreadB tb;
   ThreadA (ThreadB tb)
   {
      this.tb = tb;
   }
   public void run ()
   {
      try
      {
          Thread.sleep (5000);
      }
      catch (InterruptedException e)
      {
      }
      tb.finished = true;
   }
}
class ThreadB extends Thread
{
   public [B]volatile [/B]boolean finished = false;
   private int sum = 0;
   public void run ()
   {
      while (!finished)
      {
         System.out.println ("sum = " + sum++);
         Thread.yield ();
      }
   }
}

The volatile keyword is used so that inter thread communication is facilitated without the local memories of the threads involved coming into the picture.Only the main memory is used to access/store the variable's data.
But if global variables are already shared between threads then is the volatile keyword absolutely necessary or is it an implementation dependent usage?


[HENRY: Added code tags]
[ October 25, 2006: Message edited by: Henry Wong ]

[Peter Chase]

Looking briefly at your code, it looks like the use of "volatile" is appropriate here. A valid alternative would be to protect all accesses of "finished" by synchronisation. But "volatile", in this case, is neater.

If access to "finished" were neither protected by "volatile" nor by synchronisation, then the code might or might not work, depending on the particular JVM and sheer luck.

[venkatesh pendharkar]

hi,
I would like to know whether volatile keyword is really important or not.Because i really do not know whether under any particualr situation the compiler starts optimizing values for a variable.I guess if we know exactly in which situations ,optimization of a vaiable is going to happen then we can use volatile keyword under these situations as unnecessorily using volatile keyword can waste CPU time.