Deadlock - how does it happen in this example?

Question

can anyone explain:

1. why do we get a deadlock?
2. how can Gaston enter function bow before Alphonse exit that function? (it should return from function bowBack() in order to exit the function bow() - or)?

This is the output I get - and then program is stuck!

Alphonse: Gaston has bowed to me!

Gaston: Alphonse has bowed to me!

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();     } }  

Answer 1

The synchronized block / method is synchronized to this, that is the object instance the block / method is called. (For static "object instance" is to be replaced with "class instance".)

That is your 2 objects get synchronized to themselves, not a common object.

Try something like this:

public class Deadlock {    static class Friend {       private final String name;       public Friend(String name) {          this.name = name;       }       public String getName() {          return this.name;       }       public void bow(Friend bower) {          synchronized (getClass()) {             System.out.format("%s: %s  has bowed to me!%n", this.name, bower.getName());             bower.bowBack(this);          }       }       public void bowBack(Friend bower) {          synchronized (getClass()) {             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();    } } 

Answer 2

Thread 1: alphonse instance gets locked from alphonse.bow(gaston); which prints a line and then calls gaston.bowBack() (but gaston is locked from Thread 2 due to synchronized bow() instance called on it below)

Thread 2: gaston instance gets locked from gaston.bow(alphonse); which prints a line and then calls alphonse.bowBack()(but alphonse is locked from Thread 1 due to synchronized bow() instance called on it)

So they're both waiting for the release and cannot exit bow() method, hence the Deadlock