Java 带死锁的多线程处理

在java教程中，我看到了这个简单的死锁示例，由于某种原因，我无法理解它为什么会被阻塞

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());
            System.out.println("Nice try " + this.name);
            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();
    }
}

让我们看一些真实的例子

run:
Alphonse: Gaston  has bowed to me!
Gaston: Alphonse  has bowed to me!
Nice try Gaston
Nice try Alphonse

因此，Alphonse和Gaston现在都在运行“bow（）”，它们都在“bow（）”的末尾，试图相互调用“bowBack（）”，而“bowBack（）”不是静态的，因此Alphonse和Gaston已经分离了这个方法的实例，而且“bowBack（）”以前也没有被调用，因此不应该被阻止。那么，为什么会出现僵局呢

在教程中

它被解释为

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.

但是，为什么要运行“bowBack（）”，它应该首先等待“bow（）”的结束，如果它们不相互干扰的话

Alphonse.bow（）-->正在尝试调用-->Gaston.bowBack（））

Gaston.bow（）-->正在尝试调用-->Alphonse.bowBack（））

但是，为什么要运行“bowBack（）”，它应该首先等待“bow（）”的结束，如果它们不相互干扰的话

调用

bowBack（）

时-运行线程试图获取的锁是它试图调用其方法的

对象上的锁

这里——阿尔方斯是一个物体，加斯顿是第二个物体

Alphonse.bow（）-->正在尝试调用-->Gaston.bowBack（））

在上图中，第一个呼叫锁定了阿尔方斯，当锁定仍然保持时，试图获得加斯顿的锁定

因此，在线程1中：锁定（Alp）并尝试在不释放锁（Apl）的情况下锁定（Gaston）

Gaston.bow（）-->正在尝试调用-->Alphonse.bowBack（））

在这里，第一个弓箭（）锁定加斯顿物体，然后试图获得阿尔方斯的锁定

因此，在线程2中：锁定（Gaston）并在不释放锁（Gaston）的情况下尝试锁定（Apl）

如果线程1和线程2中的第一步都已完成，那么您可以确定第二步永远无法完成-因此出现死锁

但是，为什么要运行“bowBack（）”，它应该首先等待“bow（）”的结束，如果它们不相互干扰的话

调用
bowBack（）
时-运行线程试图获取的锁是它试图调用其方法的
对象上的锁

这里——阿尔方斯是一个物体，加斯顿是第二个物体

Alphonse.bow（）-->正在尝试调用-->Gaston.bowBack（））

在上图中，第一个呼叫锁定了阿尔方斯，当锁定仍然保持时，试图获得加斯顿的锁定

因此，在线程1中：锁定（Alp）并尝试在不释放锁（Apl）的情况下锁定（Gaston）

Gaston.bow（）-->正在尝试调用-->Alphonse.bowBack（））

在这里，第一个弓箭（）锁定加斯顿物体，然后试图获得阿尔方斯的锁定

因此，在线程2中：锁定（Gaston）并在不释放锁（Gaston）的情况下尝试锁定（Apl）

如果线程1和线程2中的第一步都已完成，那么您可以确定第二步永远无法完成-因此出现死锁

但是，为什么要运行“bowBack（）”，它应该首先等待“bow（）”的结束，如果它们不相互干扰的话

调用
bowBack（）
时-运行线程试图获取的锁是它试图调用其方法的
对象上的锁

这里——阿尔方斯是一个物体，加斯顿是第二个物体

Alphonse.bow（）-->正在尝试调用-->Gaston.bowBack（））

在上图中，第一个呼叫锁定了阿尔方斯，当锁定仍然保持时，试图获得加斯顿的锁定

因此，在线程1中：锁定（Alp）并尝试在不释放锁（Apl）的情况下锁定（Gaston）

Gaston.bow（）-->正在尝试调用-->Alphonse.bowBack（））

在这里，第一个弓箭（）锁定加斯顿物体，然后试图获得阿尔方斯的锁定

因此，在线程2中：锁定（Gaston）并在不释放锁（Gaston）的情况下尝试锁定（Apl）

如果线程1和线程2中的第一步都已完成，那么您可以确定第二步永远无法完成-因此出现死锁

但是，为什么要运行“bowBack（）”，它应该首先等待“bow（）”的结束，如果它们不相互干扰的话

调用
bowBack（）
时-运行线程试图获取的锁是它试图调用其方法的
对象上的锁

这里——阿尔方斯是一个物体，加斯顿是第二个物体

Alphonse.bow（）-->正在尝试调用-->Gaston.bowBack（））

在上图中，第一个呼叫锁定了阿尔方斯，当锁定仍然保持时，试图获得加斯顿的锁定

因此，在线程1中：锁定（Alp）并尝试在不释放锁（Apl）的情况下锁定（Gaston）

Gaston.bow（）-->正在尝试调用-->Alphonse.bowBack（））

在这里，第一个弓箭（）锁定加斯顿物体，然后试图获得阿尔方斯的锁定

因此，在线程2中：锁定（Gaston）并在不释放锁（Gaston）的情况下尝试锁定（Apl）

如果线程1和线程2中的第一步都完成了，那么您可以计算出第二步永远无法完成-因此死锁
很好，在教程中，他们让锁看起来像是为单个methodgood创建的，在教程中，他们让锁看起来像是为单个methodgood创建的，在教程中，他们让锁看起来像是为单一方法创建的好的，在教程中，他们让锁看起来像是为单一方法创建的可能重复的可能重复的可能重复的可能重复的