Re: Two more multithreading questions

From:

"Daniel Pitts" <googlegroupie@coloraura.com>

Newsgroups:

comp.lang.java.programmer

Date:

31 Jan 2007 17:22:46 -0800

Message-ID:

<1170292966.528176.151930@m58g2000cwm.googlegroups.com>

On Jan 31, 4:24 pm, "A. Bolmarcich" <agge...@earl-grey.cloud9.net>
wrote:

On 2007-01-31, Daniel Pitts <googlegrou...@coloraura.com> wrote:

On Jan 31, 11:40 am, "A. Bolmarcich" <agge...@earl-grey.cloud9.net>
wrote:

[snip]

The fact that the variable is volatile means that reads and writes by
a thread cannot be reordered to be before the previous synchronization
action or after the next synchronization action. According to section
"8.3.1.4 volatile Fields" of the JLS (fromhttp://java.sun.com/docs/books/jls/third_edition/html/classes.html#36930),
given the class

  class Test {
    static volatile int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
      System.out.println("i=" + i + " j=" + j);
    }
  }

If method one() is repeatedly called by one thread and method two() is
repeatedly called by another thread, then according to the JLS:

  Therefore, the shared value for j is never greater than that for i,
  because each update to i must be reflected in the shared value for i
  before the update to j occurs.

If the variables i and j were not volatile, then lines printed by method
two() may have a value of j greater than that of i.

Actually, they still might.
imagine this scenario:

Thread 2: two gets called
Thread 2: value i is loaded and converted to a string for
concatication
Thread 1: one gets called
Thread 1: one gets called again
Thread 1: one gets called a third time
Thread 2: continues with j

Output is i=0 j=3

Which is a case of the value of j being greater than that of i that I wrote
may occur.

You wrote:

If the variables i and j were not volatile, then lines printed by method
two() may have a value of j greater than that of i.

My example is allowing them to be volatile.
Actually, my example is valid for both volatile and non-volatile
variables.

With two threads repeatedly calling their respective methods, you can
get a situation with i > j or j > i, regardless of the volatility of
the variables.

Therefore, your post doesn't explain volatile at all.