Re: synchronization question
gk wrote:
Hi, i found an reference which says
synchronized void foo() {
/* body */
}
IS EQUIVALENT TO
void foo() {
synchronized (this) {
/* body */
}
}
so, does Synchronizing a method locks the whole object ?
It is only for convenience that synchronized works on arbitrary objects.
All that matters is that you hold the same lock object when accessing
variables. Quite often it is desirable not to expose the lock, so we
have something like this:
class MyClass
private static class Lock { }
private final Object lock = new Lock();
@GuardedBy("lock")
private int x;
@GuardedBy("lock")
private int y;
....
public void foo() {
synchronized (lock) {
++x;
--y;
}
}
}
(
The peculiar Lock class is there because the class name appears in stack
dumps - if you press ctrl-\ (or ctrl-break in Windows) from the console.
@GuardedBy is a suggested annotation that denotes which lock to hold
while accessing a variable.
)
public void M1()
{
//code
}
synchronized void M2() {
//code
}
Now, say ...one thread T1 grabbed M2() ....now, at the same time,
suppose another thread T2 wants to get M1()....is it possible for T2 to
get M1() now or it will be locked ?
Note: Assuming the same object. synchronized is about objects, not
blocks of code.
As it stands there is no problem with T2 to execute M1. If however M1
contains synchronized (this), then it will block to acquire the lock.
(As a slight complication, if M2 calls this.wait(), then it will release
the lock until it wakes up.)
Tom Hawtin