Re: Problem figuring out threading problem for SCJP
Mark Space wrote:
There are two objects named "sa". ...
lielar wrote:
If it is being synchronised in a different thread (main and t1), does
it matter?
Mark Space wrote:
It doesn't matter in this instance because two different objects are
used to synchronize two different threads. The locks and the threads
never interact.
....
Now lets see if I get totally proven wrong by someone ;)
You're totally right, Mark Space.
To the OP: What Mark pointed out is that for synchronization to work, the
locks must be taken on the *same* object. Not the same variable.
The distinction between variables and objects is quite significant. Variables
are pointers to objects (or primitives - forget them for now). Variables have
compile-time type and scope; objects have run-time type and lifespan.
Variables cannot hold locks. They have no locks. They point to objects that
have locks. (Technically, they have monitors, but that's not important here.)
The static variable
private static String sa = new String("Not Done");
is visible to the Test class only. It points initially to a new String with
the value "Not Done". The pointer to that String is passed to the MyThread
instance. The MyThread instance variable is never changed to point to a
different String thereafter.
Side note: The fact that the Test 'sa' variable is a static variable is
meaningless; it really should have been a constant (not a 'new String(...)')
or a local variable.
The statement
sa = new String("Done");
points the Test static variable 'sa' to a different object, in one thread.
That change cannot be seen in the other thread, because, a), it is never
passed to the MyThread instance, and, b), there isn't any synchronization on
involved in communicating the change to the instance.
Then the call to
sa.notify();
sends a 'wakeup' to all threads waiting on the lock for the new String with
value "Done". There aren't any.
You might also want to review the limitations of the notify() method for more
complex scenarios.
Now back to the idea of primitives. Synchronizing access to a primitive
instance variable works a little differently from object variables. Some
primitive operations are atomic, not that that excuses one from communicating
those operations synchronously.
<http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html>
--
Lew