Re: Two more multithreading questions
On Jan 31, 11:40 am, "A. Bolmarcich" <agge...@earl-grey.cloud9.net>
wrote:
On 2007-01-31, Knute Johnson <nos...@rabbitbrush.frazmtn.com> wrote:
Thanks very much for your response. The two actions are independent and
I do not want to effect when they occur. I just want to ensure that if
an assignment is made to the variable that any subsequent read in the
other thread will have the latest value.
Without any other sychronization action between the threads, the only
way you know that a read was subsequent to a write is based on the value
that was read. A read is subsequent to a write that wrote the value
that was read.
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
Also possible is:
Thread 1: one gets called
Thread 1: increments i
Thread 2: one gets called
Thread 2: increments i
Thread 3: two gets called
Thread 3: output i=2 j=0
Thread1: increments j
Thread2: increments j
A even worse possibility:
Thread 1: reads value of i
Thread 2: reads value of i
Thread 1: writes value of i+1 back to i
Thread 2: writes values of i+1 back to i
Thread 1: increments j
Thread 2: increments j
Thread 3: wait for thread1 and thread2
Thread 3: call two
Output i=1 j=2