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

当我运行该程序时，我得到的输出为

阿方斯：加斯顿向我鞠躬！
加斯顿：阿方斯向我鞠躬！

那么，两个线程可以同时访问同步方法吗？

最佳答案

两个线程可以同时访问同步方法吗？


这取决于两个线程试图锁定的对象实例。两个线程不能在同一对象实例上访问相同的synchronized方法。一个将获得锁定，另一个将阻塞，直到第一个线程离开该方法。

在您的示例中，实例方法在包含它们的对象上同步。在这种情况下，调用alphonse.bow(...)时将锁定alphonse对象。 gaston.bow(...)锁定gaston。

您可以通过两种方法来获取一个对象的多个实例以锁定同一对象。


您可以将方法设为static和synchronized，在这种情况下，它们将锁定类对象本身。每个类加载器只有这些对象之一。

public static synchronized void bow(Friend bower) {

它们都可以锁定已定义的静态对象。就像是：

private static final Object lockObject = new Object();
...
public void bow(Friend bower) {
    synchronized (lockObject) {
        ....
    }
}

或者，如果您不想将其设为静态，则可以传入该对象以进行锁定。




您的输出可能类似于以下内容：


gaston线程（可以）首先启动并调用bow(alphonse)
这将锁定gaston对象并输出：Gaston: Alphonse has bowed to me!
它调用alphonse.bowBack(this)。
该调用将锁定alphonse对象并输出：Alphonse: Gaston has bowed back to me!
alphonse.bowBack(this)退出，解锁alphonse对象。
gaston.bow(alphonse)退出，解锁gaston对象。
然后gaston线程退出。
alphonse线程（可能）接下来开始并调用bow(gaston)
这将锁定alphonse对象并输出：Alphonse: Gaston has bowed to me!
它调用gaston.bowBack(this)。
该调用将锁定gaston对象并输出：Gaston: Alphonse has bowed back to me!
gaston.bowBack(this)退出，解锁gaston对象。
alphonse.bow(gaston)退出，解锁alphonse对象。


这可能会以许多不同的顺序发生。即使在以后调用alphonse方法，start()线程也可以首先运行。如果当前正在运行alphonse.bow(...)，锁将使您从中唯一摆脱的是alphonse.bowBack(...)的调用。正如@ user988052指出的那样，因为每个线程都锁定自己的对象，然后尝试锁定另一个对象，所以很容易会出现死锁。