🚀 go-pugleaf

Hello!

As I understand, threads create a local copy of variables which allows them
to execute faster.
They retrieve the master copy only after exiting or entering a synchronized
block or the thread itself.

Here comes the meaning of volatile which is to say that the variable may
change by other threads so each thread using it, always looks at the master
copy.

I've written a simple program which tried to illustrate the volatile's
essence in life:

public class VolatileTest implements Runnable {

  // Should be volatile to work as expected!!!
  private int value;

  public VolatileTest() {
    value = 10;
  }


  public void run() {

    while(value == 10)
      System.out.println("in run() - value=" + value);

    System.out.println("leaving run()");
  }


  public void changeValue(int newValue) {
    value = newValue;
  }


  public static void main(String[] args) {
    VolatileTest vol = new VolatileTest();
    Thread t = new Thread(vol);

    t.start();

    // Snoozing a little in main

    try { Thread.sleep(2000); }
    catch(InterruptedException x) { System.err.println("sleep() interrupted
in main()"); }

    System.out.println("in main() - about to change the variable value");
    vol.changeValue(99);

    System.out.println("leaving main()");
  }

} // end class VolatileTest


The variable "value" was NOT declared volatile but it acts this way.
If it wasn't volatile, the inner thread should have NOT noticed the change
in variable "value" and would continue to execute indefinitly.
This is not the case however.

Can someone help me with this?

P.S.

Is there a newsgroup about threads somewhere?