Java中的同步如何工作

Question

首先，这是一个示例：

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

我没有得到的是堵塞如何发生。main函数启动两个线程，每个线程都开始各自的弓箭操作。

“同步”到底阻止了什么？为同一对象运行的功能相同（就像我最初想的那样）？同一类的所有对象具有相同的功能吗？同一对象的所有同步功能？同一类所有对象的所有同步功能？

Answer 1

在Java中，每个函数都Object提供了synchronize在其上锁定或锁定线程的功能。同步方法时，该方法将其对象实例用作锁。在你的示例中，方法bow和bowBack都属于synchronized，并且都位于同一类中Friend。这意味着任何执行这些方法的线程都将在Friend实例上作为其锁进行同步。

一系列将导致死锁的事件是：

1. 第一个线程调用开始alphonse.bow(gaston)，这是synchronized在上alphonse Friend对象。这意味着线程必须从该对象获取锁。
2. 第二个线程开始通话gaston.bow(alphonse)，这是synchronized在上gaston Friend对象。这意味着线程必须从该对象获取锁。
3. 现在启动的第一个线程将调用bowback并等待gaston释放锁定。
4. 现在启动的第二个线程将调用bowback并等待alphonse释放锁定。

为了更详细地显示事件的顺序：

1. main()开始在主要Therad中执行（称为线程1），创建两个Friend实例。到目前为止，一切都很好。
2. 主线程使用代码开始其第一个新线程（称为线程＃2）new Thread(new Runnable() { ...。线＃2的呼叫alphonse.bow(gaston)，这是synchronized在上alphonse Friend对象。因此，线程＃2获取alphonse对象的“锁” 并进入bow方法。
3. 时间片在这里发生，原始线程有机会进行更多处理。
4. 与第一个线程一样，主线程将启动另一个新线程（称为线程＃3）。线程＃3调用gaston.bow(alphonse)，它在gaston Friend对象上同步。由于还没有人获得gaston对象实例的“锁”，因此线程＃3成功获取了此锁并进入了bow方法。
5. 这里发生一个时间片，线程2获得了进行更多处理的机会。
6. 线＃2现在调用bower.bowBack(this);与bower正在该实例的引用gaston。这在逻辑上等效于的调用gaston.bowBack(alphonse)。因此，此方法synchronized在gaston实例上。该对象的锁已被获取，并由另一个线程（线程3）持有。因此，线程＃2必须等待gaston释放锁定。线程进入等待状态，从而允许线程＃3进一步执行。
7. 现在bowback，线程＃3进行了调用，在这种情况下，它在逻辑上与call相同alphonse.bowBack(gaston)。为此，它需要获取alphonse实例的锁，但是此锁由线程＃2持有。现在，该线程已进入等待状态。

现在，你处于无法执行任何线程的位置。线程＃2和线程＃3都在等待释放锁。但是，如果没有Thread进展，则无法释放任何锁定。但是没有释放锁，任何线程都无法取得进展。

因此：死锁！

死锁通常取决于发生的事件的特定顺序，这可能使调试变得困难，因为它们可能难以重现。