System.out.format 和 System.out.println 的多线程

Question

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

所以在这个例子中，我在第 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

你搞混了。

一段代码可以导致死锁情况的事实并不一定意味着您每次都会收到死锁任何时候代码运行s。

这是使多线程成为一个难题的方面之一：如果您运行您的代码一次，或 10 次，或 100 次，以及一切 "works"；下次还是有可能失败。

换句话说：尝试将该代码放在最外层的循环中，迟早（可能更早；如果您不做太多 "sleeping"），您应该会陷入僵局！

如果事情有那么简单并且可以很容易地检测到死锁，我们就不需要那么多书籍和图书馆以及如何处理多线程的想法...

Answer 2

死锁根本不依赖于println函数。这是由于两个线程试图互相访问，并互相锁定造成的。

从 format 到 println 的更改将在程序中引入足够的延迟，以允许线程相互锁定而不会发生冲突，即死锁。所以你还没有真正修复它；您刚刚添加了一些延迟，这意味着线程不会死锁。

Answer 3

使用 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 可以 return 不同对象的相同值；但这不太可能。

这是Birthday paradox的一个应用：如果你只有两个显示器，碰撞的几率大约是10^-18；但如果你有超过 77k 的显示器，则更有可能发生冲突。

Answer 4

为了用一些实际证据来支持这里的其余答案，我运行你的代码在一个循环中，它在 100 次尝试中死锁了 82 次，所以你的代码肯定仍然死锁。

System.out.format 和 System.out.println 的多线程

Mutithreading with System.out.format and System.out.println

java

multithreading

deadlock

println