The Java™ Tutorials — Concurrency ：Deadlock 死锁

The Java™ Tutorials — Concurrency ：Deadlock 死锁

原文地址：https://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html

关键点

• 发生条件： 
  
  • 请求和保持
  • 资源互斥
  • 循环等待
  • 不可抢夺

全文翻译

Deadlock describes a situation where two or more threads are blocked forever, waiting for each other. Here’s an example.

死锁描述了这样一种情况——一个或多个线程永远地阻塞，并一直等待着对方。看这个例子。

Alphonse and Gaston are friends, and great believers in courtesy. A strict rule of courtesy is that when you bow to a friend, you must remain bowed until your friend has a chance to return the bow. Unfortunately, this rule does not account for the possibility that two friends might bow to each other at the same time. This example application, Deadlock, models this possibility:

Alphonse和Gaston是好友，并释放注意礼节。礼节中一个严苛的规定就是，当你想一个朋友鞠躬时，你必须保持鞠躬的姿势知道你的朋友有机会起身。不幸的是，此规则无法对这种情况适用，那就是两个朋友同时向对方鞠躬。下面的这个程序，Deadlock，很好地模拟了这个场景：

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

When Deadlock runs, it’s extremely likely that both threads will block when they attempt to invoke bowBack. Neither block will ever end, because each thread is waiting for the other to exit bow.

当Deadlock运行时，两个线程在尝试调用bowBack时发生阻塞。两边的阻塞都不会停止，因为它们都在等待对方退出bow。