Question

我发现在经典Java Deadlock Tutorial中包含对System.out.format的调用可以防止发生死锁，我无法弄清楚原因。

以下代码与教程相同，但main增加System.out.format("Hi, I'm %s...no deadlock for you!\n\n", alphonse.getName());

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) throws InterruptedException {
        final Friend alphonse = new Friend("Alphonse");
        final Friend gaston = new Friend("Gaston");

        System.out.format("Hi, I'm %s...no deadlock for you!\n\n", alphonse.getName());

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

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

这是输出：

Hi, I'm Alphonse...no deadlock for you!

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!

删除违规行会导致通常的死锁：

Alphonse: Gaston has bowed to me!
Gaston: Alphonse has bowed to me!
... deadlock ...

对System.out.format的调用是否以某种方式改变了线程获取对象的内部锁的方式？

更新

我只是通过更改代码中启动线程的位置来再次使系统死锁：

public static void main(String[] args) throws InterruptedException {
    final Friend alphonse = new Friend("Alphonse");
    final Friend gaston = new Friend("Gaston");

    System.out.format("Hi, I'm %s...no deadlock for you!\n\n", alphonse.getName());

    Thread t1 = new Thread(new Runnable() {
        public void run() { alphonse.bow(gaston); }
    });

    Thread t2 = new Thread(new Runnable() {
        public void run() { gaston.bow(alphonse); }
    });

    t1.start();
    t2.start();
}

这引出了一个问题，即如何让我们更深入地了解线程调度程序的行为，但我将在不同的日子保存它。

Answer 1

你没有真正删除死锁，而是（因为一些内部JVM原因）改变了线程的时间，以便其中一个线程在<{1}}之前进入 / em>其他来电bowBack()。只需加入bow()：bow，您的僵局就会重新出现。

请注意，只有当线程处于 lucky 时序时，死锁才会始终发生。在这种情况下，当两个线程都进入sleep(1000)并且在其中任何一个调用bow
之前，就会发生死锁
... “一些内部JVM原因”可以是：

在您的情况下，实际上有三个线程：执行 main ， t1 和 t2 的线程。将 print 隐藏死锁的原因可能是线程调度程序决定bowBack仍有工作要做，即刷新io缓冲区，因此让 print 在启动 t1 之后和启动t2之前继续。如果您使用的是双核cpu，则只会运行main和main，但t1会等待，因为t2是一个缓慢的操作。上下文切换需要一些时间， t1 将在 t2 启动之前完成...因此不会发生死锁。但这并不意味着如果你再次运行程序就不会发生死锁。

如果你想玩，在该队列中创建一个print并推送令牌（线程名称），然后在main中创建queue个线程。完成后，打印队列内容，您可以观察线程的时间。

Answer 2

format()并且写入控制台通常是费用操作。我猜它的执行正在改变线程启动的时间，所以第二个线程启动太晚以至于它不会干扰第一个线程。

System.out.format如何防止死锁？

2 个答案: