java - 当线程调用 wait 时，它会释放锁而不是竞争条件

Question

根据源码中同步方法的基本定义 - link

“当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞(挂起执行)，直到第一个线程完成该对象。”

我读到了关于wait()的内容，它在 sleep 之前释放了一个锁。这里存在一个困惑，如果wait释放锁，那么其他线程可以进入同步方法并执行这是有道理的，因为它可能会导致竞争条件？

这是我的示例代码，它允许一个和两个线程进入同步块(synchronized block)。

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Ashish Pancholi
 */
public class Test {

    public Test() {
        Sharing sharing = new Sharing();
        Worker worker_ = new Worker(sharing);
        Thread thread_ = new Thread(worker_, "one");
        Worker worker = new Worker(sharing);
        Thread thread = new Thread(worker, "two");
        thread_.start();
        thread.start();
    }

    public static void main(String[] argu) {
        Test test = new Test();
    }

    public class Worker implements Runnable {

        private Sharing sharing;

        public Worker(Sharing sharing) {
            this.sharing = sharing;
        }

        @Override
        public void run() {
            sharing.check();
        }
    }

    public class Sharing {

        public void check() {
            synchronized (this) {
                System.out.println("Thread IN " + Thread.currentThread().getName());
                try {
                    wait(5000);
                } catch (InterruptedException ex) {
                }
                System.out.println("Thread OUT " + Thread.currentThread().getName());
            }
        }
    }
}

输出-

Thread IN one
Thread IN two
Thread OUT one
Thread OUT two

Answer 1

是的，这是有道理的。

wait() 方法的 API 表示:

Causes the current thread to wait until either another thread invokes the notify() method or the notifyAll() method for this object, or a specified amount of time has elapsed.

因此，如果 wait 方法不释放监视器对象上的锁，则没有其他线程可以获得它，因此没有其他线程可以调用 notify 或 该监视器对象上的notifyAll。

wait(5000) 表示当前线程将等待最多 5000 毫秒的通知，然后再继续或在 5000 毫秒后继续。如果您想保持锁定并暂停 5000 毫秒，则必须使用 Thread.sleep(5000)。