lielar wrote:
Hi
Still stuck on threading question. (Someone will probably recognise
this)
I have the following thread class
<snip>-------------------------------------------------------
class MBThread extends Thread {
String name;
OrderedThread orderT;
What's an OrderedThread? It doesn't seem to have
any essential role in the code or on your questions;
I'm just curious.
MBThread(String name, OrderedThread orderT) {
this.name = name;
this.orderT = orderT;
}
public void run() {
orderT.display(name);
}
}
public class MBTHread {
public void display(String msg) {
synchronized(msg) {
for (int i=0; i<20; i++) {
System.out.println("Name= "+msg);
}
}
}
public static void main(String [] args) {
OrderedThread orderedT = new OrderedThread();
MBThread first = new MBThread("One", orderedT);
MBThread second = new MBThread("Two", orderedT);
first.start();
second.start();
}
}
<snip>-------------------------------------------------------
My Questions
--------------------
1) Here the string object is synchronised. What is the difference
between the string reference being synchronised as opposed to the
whole method? Does it mean that any thread can access the method but
only one thread can access the object?
Synchronization always uses an object instance. The
object's lock ("monitor") is acquired before the stretch
of synchronized code starts executing, and is held throughout
its execution. Since only one thread at a time can hold a
particular object's lock, only one thread at a time can be
executing a piece of code that is synchronized on that object.
Your code identifies the locked object explicitly: it
is the object referred to by the msg argument of the display
method. As it happens, this will be the String object "One"
in one thread and the String object "Two" in the other; these
are different objects, so they can be locked and unlocked
independently; the two threads do not get in each other's
way. (Not in this code, anyhow: The methods of System.out
most likely have additional synchronization, and the two
threads might squabble over locks while printing output.)
When you apply `synchronized' to an entire method you
can omit the specification of which object's lock should be
used. If you do, Java assumes you mean the method's `this'
object (for a static method, where there is no `this', Java
assumes you mean the class' Class object). Everything works
just as above, except that a different object is locked
while the synchronized method runs.
2) If I synch another object would the outcome be different if it is
mutable (unlike String)?
The object's mutability or immutability makes no difference.
The object's *identity* might make a difference, in the sense
that if both threads synchronize on the same object they will
affect each other's progress.
3) What is the difference between synching the instance, the class
(MBThread.class), an object, and method?
For the first three, it's just a matter of which object's
lock is held while the synchronized code executes: the `this'
object, or a Class object, or some other object. The fourth
isn't really answerable: you don't "synchronize on a method,"
you "synchronize on some object while executing a method."
--
Eric.Sos...@sun.com