在 Java 中使用“同步”代码块和“.wait”和“.notify”

Question

我正在学习同步的代码块和wait（）/。notify（）方法，我很难理解它们在生产者-消费者设置中如何交互。将下面类的同一实例传递给两个线程；一个线程运行生产者方法，另一个线程则运行消费者方法。

    private Queue<Integer> queue = new LinkedList<>();
    private Object lock = new Object();

    public void producer() throws InterruptedException {
        Random random = new Random();
        while (true) {

            synchronized(lock) {
                while (queue.size() > 10) {
                    lock.wait();
                }

                queue.add(random.nextInt(100));
                lock.notify();
            }

        }
    }

    public void consumer() throws InterruptedException {
        while (true) {

            synchronized(lock) {
                if (queue.isEmpty()) {
                    lock.wait();
                }

                int val = queue.remove();
                System.out.println(val + ": " + queue.size());
                lock.notify();
            }

        }
    }

}

这里，同一个对象上的< code>synchronized使得两个代码块中只有一个同时运行。假设生产者线程赢得了比赛，向队列添加一个元素，并调用notify。此时，消费者线程将在消费者函数中的< code>synchronized(lock)处等待(由于< code > synchronized ，它从未进入其代码块)。一旦生产者线程退出它的同步代码块，消费者线程将进入它的。现在，队列是非空的，因为生产者只是在通知之前放了一些东西进去。消费者线程将移除它，调用notify，退出它的块，此时生产者将获得锁，因为它现在已经在生产者函数中的< code>synchronized(lock)行等待。三个问题:

> < li>

在我看来，我们在生产者和消费者之间交替，因此队列大小将在0和1之间波动。我错过了什么？

既然退出同步代码块释放了等待线程可以看到和获取的锁，为什么我们需要整个等待和通知机制呢？在我看来，我上面描述的通知没有做任何事情，因为一旦锁可用，另一个线程就会获取它并输入其代码块。

lock.notify（） 是否也会唤醒在 synced（lock） 处等待的线程？

Answer 1

您正在看到线程匮乏的示例。

饥饿发生的一种方式是，如果您这样编写循环：

while (true) {
    synchronized(lock) {
        ...
    }
}

问题是，线程在释放< code>lock后做的下一件事就是再次锁定它。如果任何其他线程当前被阻塞等待同一个锁，那么执行这个循环的线程几乎肯定会赢得再次锁定它的竞争，因为执行该循环的线程已经在运行，但是其他线程需要时间来“唤醒”

在这种情况下，我们说另一个线程“饥饿”。

一些线程库提供了所谓的公平锁，通过确保锁总是授予等待时间最长的线程来避免饥饿。但是公平锁通常不是默认的，因为它们损害了设计更好的程序的性能，在这些程序中锁没有被激烈竞争。

在您的示例中，饥饿并不是一场彻底的灾难，因为每个线程在用完工作时都会调用wait（）。这将释放锁并允许其他线程运行。但它几乎迫使线程“轮流”：一个将始终处于睡眠状态，而另一个线程正在工作。您也可以将其编写为单线程程序。

如果您的线程不保持任何锁定超过绝对必要的时间，那会更好:

while (true) {
    int val;
    synchronized(queue_lock) {
        if (queue.isEmpty()) {
            lock.wait();
        }

        val = queue.remove();
        queue_lock.notify();
    }
    System.out.println(val + ": " + queue.size());
}

在这里，我将< code>println(...)从同步块中调用。(我还重命名了您的< code>lock变量，以强调它的具体目的是保护队列。)

通过将＜code＞random（）

澄清一下：这是实际可能发生的事情：

producer                              consumer
---------------------------------     -----------------------------------
                                      enter synchronized block
tries to enter synchronized block     queue.isEmpty() => true
                                      lock.wait()
                                          ...releases the lock...
enters synchronized block                 ...awaiting notification...
queue.add(...)                            ...awaiting notification...
lock.notify()                             ...now awaiting the lock...
leave synchronized block                  ...starts to wake up, but...
enter synchronized block                  ...Dang! Lost the race...
queue.add(...)                            ...awaiting the lock...
lock.notify()
leave synchronized block                  ...starts to wake up, but...
enter synchronized block                  ...Dang! Lost the race...
    .                                     ...awaiting the lock...
    .                                          .
    .                                          .
queueSize() > 10                               .
lock.wait()
    ...releases the lock...               ...starts to wake up, and...
    ...awaiting notification...           ...FINALLY! re-acquire the lock, and...
         .                             lock.wait() returns
         .                             val = queue.remove()
         .                             ...
    ...now awaiting the lock...        lock.notify()
    ...starts to wake up, but...       leave synchronized block
    ...Dang! Lost the race...          enter synchronized block
         .                               .
         .                               .
         .                               .

Answer 2

请检查通知的整个留档并等待