Locking on objects

Question

I need clarification on what object gets locked when you say
synchronized( lockObj )
// Do something
Assume that both the class that contains the above snippet as well as the class of lockObj have synchronized methods. Now, when a thread enters the critical section, does the jvm prevent other threads from accessing the synchronized methods of this object or of lockObj (or both)?
I have seen in Item 52 of Effective Java that Bloch shows an example of locking the backing Hashtable when obtaining a key Enumeration. This implies that the lockObj gets 'locked'. But in the same item, at the end a code snippet is shown where a private 'lock' object is used to block access to synchronized methods of the object having the private 'lock' object. I am confused!

Answer 1

Given you have:
public class MyClass1
    private MySemaphore semaphore;
    public synchronized void mehotd1()
    public void method2()
        synchronized(semaphore)
    public void synchronized void mehotd3()
public class MySemaphore
    public synchronized void sema1()
    public void synchronized void sema2()
}Now let say you have 3 threads, named thread1, thread2 and thread3.
If thread1 execute method1(), a lock will be set on the MyClass object and while the lock is on, if thread2 try to access either method1 or method3, it will go in a waiting queue until thread1 finish to execute method1. However thread2 can still access method2 as it don't lock on the MyClass object, but on the MySemaphore one. While thread2 would be executing method2 code, thread1 and thread3 would not be able to execute sema1() or sema2() as those requires a lock on the MySemaphore object, a lock that is owned by thread2.
This said synchronization can cause dead lock, look at this code:
public class MyClass
    public synchronized void foo(Object semaphore)
        // Some code
        synchronized(semaphore)
            // Some more code
public class MyThread extends Thread
    private MyClass object;
    private MyClass semaphore;
    public MyThread(MyClass object, MyClass semaphore)
        this.object = object;
        this.semaphore = semaphore;
    public static void main(String[] args)
        MyClass object1 = new MyClass();
        MyClass object2 = new MyClass();
        MyThread thread1 = new MyThread(object1, object2);
        MyThread thread2 = new MyThread(object2, object1);
        thread1.start();
        thread2.start();
    public void run()
        object.foo(semaphore);
}This code may lock the JVM as what may happen is:
thread1 call object1.foo(object2) and acquires the lock on object1 (foo is synchronized)
thread2 call object2.foo(object1) and acquires the lock on object2
thread1 execute "some code" of foo method and reach the synchronized(object2) part so go in thw waiting queue as the lock on object2 is held by thread2
thread2 execute "some code" of foo method and reach the synchronized(object1) part so go in thw waiting queue as the lock on object1 is held by thread1
Everything is in the waiting queue and cannot resolve.
Basically synchronizing on more than one object can be dangerous. Sometimes it is needed but it requires the programmer to think twice about it.
Regards