Java，具有同步方法的多线程

Question

I am having some trouble getting my program to not deadlock at times. I think I need to add a third synchronized method release, which can be used to release the other thread after a ping is called. code is below.

// Attempt at a simple handshake.  Girl pings Boy, gets confirmation.
// Then Boy pings girl, get confirmation.
class Monitor {
    String name;

    public Monitor (String name) { this.name = name; }

    public String getName() {  return this.name; }

     // Girl thread invokes ping, asks Boy to confirm.  But Boy invokes ping,
    // and asks Girl to confirm.  Neither Boy nor Girl can give time to their
    // confirm call because they are stuck in ping.  Hence the handshake 
    // cannot be completed.
    public synchronized void ping (Monitor p) {
      System.out.println(this.name + " (ping): pinging " + p.getName());
      p.confirm(this);
      System.out.println(this.name + " (ping): got confirmation");
    }

    public synchronized void confirm (Monitor p) {
       System.out.println(this.name+" (confirm): confirm to "+p.getName());
     }
}

class Runner extends Thread {
    Monitor m1, m2;

    public Runner (Monitor m1, Monitor m2) { 
      this.m1 = m1; 
      this.m2 = m2; 
    }

    public void run () {  m1.ping(m2);  }
}

public class DeadLock {
    public static void main (String args[]) {
      int i=1;
      System.out.println("Starting..."+(i++));
      Monitor a = new Monitor("Girl");
      Monitor b = new Monitor("Boy");
      (new Runner(a, b)).start();
      (new Runner(b, a)).start();
    }
}

Answer 1

When some operation needs to get hold of two different locks the only way of ensuring that there are no deadlocks is to make sure that every thread trying to perform those operations acquires the lock on the multiple objects in the same order.

To fix deadlock you need to modify the code like this - not pretty, but it works.

 public void ping (Monitor p) {
  Monitor one = this;
  Monitor two = p;
  // use some criteria to get a consistent order
  if (System.identityHashCode(one) > System.identityHashCode(two)) {
    //swap
    Monitor temp = one;
    one = two;
    two = one;
  }
  synchronized(one) {
       synchronized(two) {
           System.out.println(this.name + " (ping): pinging " + p.getName());
           p.confirm(this);
           System.out.println(this.name + " (ping): got confirmation");
        }
  }
}

Answer 2

This is tricky stuff. I'd make Monitor.name volatile , or synchronize it with its own lock object. Or best yet: make it final . Then ditch the synchronized keyword from your two methods. Other than "name", there's nothing in there that's not thread safe.

Otherwise, don't synchronize until you need to. Use synchronized blocks, not methods. Don't put anything into a synch block unless it needs to be there. Synch fields separately on separate lock objects if you can. Don't nest synch blocks, but if you have to always nest them in the same sequence; have a hierarchy of synch objects.

Synching all your methods is a simple, handly technique for staying thread safe. However, it's easy to deadlock or just slow way down when your threads start interacting. Then it gets interesting.