Java阻塞队列：入队时为何要在队列大小为0时调用notifyAll()？

Great question! Let's unpack this with the code snippet you provided and the core logic of producer-consumer models that blocking queues rely on.

First, let's set the context: this is a simple synchronized blocking queue implementation. Producers call enqueue() to add items, and we can infer consumers would have a corresponding dequeue() method that looks roughly like this:

public synchronized Object dequeue() throws InterruptedException {
    while (this.queue.size() == 0) {
        wait(); // Block if queue is empty, wait for items to become available
    }
    // ... rest of the dequeue logic to remove and return an item
}

Now let's break down why that specific notifyAll() call matters:

• It wakes up blocked consumers: When the queue is empty, any consumer thread that tried to dequeue would have hit the wait() call and parked itself, waiting for a signal that items are ready. If we add the first item to an empty queue without notifying these threads, they'll stay blocked forever—they have no way of knowing new items are available.
• Only needed when transitioning from empty to non-empty: We don't need to call notifyAll() every time we enqueue an item. If the queue already had items before this enqueue, consumers are either actively processing items or will recheck the queue state once they wake up naturally. The only critical moment is when the queue shifts from completely empty to having at least one item—this is when blocked consumers need to be alerted.
• Why notifyAll() instead of notify()? Using notify() would only wake up one random waiting thread. If multiple consumers are blocked, the others would remain stuck. notifyAll() ensures all waiting consumer threads are woken up, so they can compete for the lock and recheck the queue state. While this can cause a minor "thundering herd" effect (multiple threads waking up only to find the queue empty again if another thread took the item first), it's the safest way to guarantee no consumer is left permanently blocked.

Let's walk through a concrete scenario to make it clearer:

1. 3 consumer threads call dequeue() when the queue is empty. All hit wait() and release the synchronized lock.
2. A producer calls enqueue(), sees the queue size is 0, so it triggers notifyAll().
3. All 3 consumer threads wake up, re-acquire the lock one by one, and check the queue state. The first thread takes the new item, the others might find the queue empty again and go back to waiting—but that's exactly the expected behavior for a blocking queue.

Without that notifyAll() call, those 3 consumers would never wake up, even after the producer added an item to the queue.

内容的提问来源于stack exchange，提问作者Manan Mehta