Java 线程在 notifyAll 之后竞争

Question

我想知道在这种情况下会发生什么:我有 10 个线程在某些 lockObject 上等待(使用 wait)和 1 个线程(我们称之为 X 线程)试图进入由 lockObject 同步的 block 。那么这个等待进入synchronized block 的X线程会不会最后执行呢？没有看到文档来说明这件事。但在实践中我尝试了这个并且 X 线程总是最后执行。我知道当我们谈论并发时，“在实践中”并不是证明，但仍然......我错过了什么或？提前致谢。

附言这是我的意思:

public class Main {
public static void main(String[] args) {

    final Object lock = new Object();

    for (int i = 0; i < 500; ++i) {
        Thread t = new Thread(() -> {
            String currentThreadName = Thread.currentThread().getName();
            try {

                synchronized (lock) {
                    System.out.println("Start waiting: " + currentThreadName);
                    lock.wait();
                    System.out.println("End of synchronized: " + currentThreadName);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Thead enddds: " + currentThreadName);

        });

        t.setName("Thread: " + i);
        t.start();
    }

    try {
        Thread.sleep(1000);
        synchronized (lock) {

            new Thread(() -> {
                Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
                System.out.println("X Threaaaaaaaad is starteeeeed");
                synchronized (lock) {
                    System.out.println("X Threaaaaaaaad");
                }
            }).start();

            Thread.sleep(100);
            lock.notifyAll();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

 }
}

Answer 1

如果 10 个线程正在等待 lockobject，那么新线程 x 将立即执行，因为所有其他线程都在等待。

当线程在 wait() 调用后进入等待状态时，它会释放对象上的锁。所以新线程会获取对象锁并开始执行。当某个线程在同一个对象上调用 notify() 或 notifyAll() 时，所有 10 个线程都会启动，否则它们将永远等待。

线程的实际执行将取决于调度，但是 lockobject 上的锁的可用性将使线程 x 立即开始执行。