Question

Below is code directly from the Sun tutorials describing Deadlock. I however don’t understand how Deadlock can occur in this situation considering both methods are synchronized. How would two Threads be inside the same synchronized methods at the same time?

Deadlock describes a situation where two or more threads are blocked forever, waiting for each other. Here’s an example.

Alphonse and Gaston are friends, and great believers in courtesy. A strict rule of courtesy is that when you bow to a friend, you must remain bowed until your friend has a chance to return the bow. Unfortunately, this rule does not account for the possibility that two friends might bow to each other at the same time. This example application, Deadlock, models this possibility:

public class Deadlock {
    static class Friend {
        private final String name;
        public Friend(String name) {
            this.name = name;
        }
        public String getName() {
            return this.name;
        }
        public synchronized void bow(Friend bower) {
            System.out.format("%s: %s has bowed to me!%n", 
                    this.name, bower.getName());
            bower.bowBack(this);
        }
        public synchronized void bowBack(Friend bower) {
            System.out.format("%s: %s has bowed back to me!%n",
                    this.name, bower.getName());
        }
    }

    public static void main(String[] args) {
        final Friend alphonse = new Friend("Alphonse");
        final Friend gaston = new Friend("Gaston");
        new Thread(new Runnable() {
            public void run() { alphonse.bow(gaston); }
        }).start();
        new Thread(new Runnable() {
            public void run() { gaston.bow(alphonse); }
        }).start();
    }
}

When Deadlock runs, it’s extremely likely that both threads will block when they attempt to invoke bowBack. Neither block will ever end, because each thread is waiting for the other to exit bow.

Answer 1

Synchronized (instance) methods lock on the object, NOT on the class.

alphonse.bow grabs the lock on alphonse and gaston.bow grabs the lock on gaston. When the ‘alphonse’ thread is in bow, it tries to grab the lock on ‘gaston’ at bower.bowBack. Likewise, ‘gaston’ tries to grab the lock on ‘alphonse’.

Edit for clarity (I hope):

Let’s call the two threads Thread1 and Thread2.

Thread1 runs alphonse.bow(gaston), where it grabs the lock on the alphonse object while Thread2 runs gaston.bow(alphonse) and grabs the lock on the gaston object.

In Thread1, when it attempts to run bower.bowBack(this), where bower = gaston, the thread needs to first acquire the lock on gaston.

While this is going on, Thread2 tries to do the same thing, with bower = alphonse. Thread1 has a lock that Thread2 needs and vice-versa, which is why the deadlock occurs.

As an aside, a deadlock need not always occur. If Thread1 can start and finish before Thread2 has a chance to do so (e.g. if something hangs the main thread after Thread1 has started but before Thread2 is created/started), then no deadlock will occur.