使用System.out.format和System.out.println进行多线程

Question

我在Oracle
Java教程中遇到了这个示例，该示例描述了多线程场景中的死锁。

因此，在此示例中，我在第17行和第18行进行了以下更改。

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) {
        //My Changes
        //System.out.format("%s: %s" + " has bowed to me!%n", this.name, bower.getName()); //Line 17
         System.out.println(this.name + ": " + bower.getName() + " has bowed to me!"); //Line 18
        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() {
        @Override
        public void run() {
            alphonse.bow(gaston);
        }
    }).start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            gaston.bow(alphonse);
        }
    }).start();
  }
}

完成这些更改后，程序将成功终止，而不会导致死锁，并在输出后进行打印

Alphonse: Gaston has bowed to me!
Gaston: Alphonse has bowed back to me!
Gaston: Alphonse has bowed to me!
Alphonse: Gaston has bowed back to me!

所以我的问题是-为什么会这样表现？println语句如何防止死锁？

Answer 1

无论您使用System.out.print还是，都没有什么区别System.out.format：它们基本上是在做同一件事。

如果Gaston.bow(Alphonse)在Alphonse.bow(Gaston)和的开始之间开始执行，则在此处发生死锁bower.bowBack(Alphonse)（反之亦然）：两个线程正在等待另一个线程持有的监视器，因此发生死锁。

出现这种情况不一致，因为它依赖于一个微妙的时机的问题，这取决于线程是如何安排-
这是可能的，Alphonse.bow并且bower.backBack(Alphonse)完成前Gaston.bow被执行，所以看起来没有僵局。

解决此问题的经典方法是对锁进行排序，以使第一个锁每次都首先获取相同的锁。这样可以防止发生死锁：

public void bow(Friend bower) {  // Method no longer synchronized.
  int firstHash = System.identityHashCode(this);
  int secondHash = System.identityHashCode(bower);

  Object firstMonitor = firstHash < secondHash ? this : bower;
  Object secondMonitor = firstHash < secondHash ? bower : this;
  synchronized (firstMonitor) {
    synchronized (secondMonitor) {
      // Code free (*) of deadlocks, with respect to this and bower at least.
    }
  }
}

（*）这不是 很 保证自由是僵局，因为System.identityHashCode可以换取不同的对象相同的值; 但这不太可能。

这是生日悖论的一种应用：如果只有两个监视器，则发生碰撞的机会约为10
^ -18；但是如果您的显示器> 77k，则很可能发生碰撞。