Spurious Wakeup in Java

Direct Answer

A spurious wakeup is a permitted return from wait() even though no notification, interruption, or timeout explains it. Java requires waiting code to recheck its condition in a while loop. The loop is also necessary because another awakened thread may make the condition false before this thread reacquires the monitor.

Code Example

import java.util.LinkedList;
import java.util.Queue;

class SafeQueue<T> {
    private final Queue<T> items = new LinkedList<>();
    private final int capacity;

    public SafeQueue(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(T item) throws InterruptedException {
        while (items.size() >= capacity) {  // WHILE not IF
            wait();  // may wake spuriously
        }
        // When we reach here, we KNOW size < capacity
        items.add(item);
        notifyAll();
    }

    public synchronized T take() throws InterruptedException {
        while (items.isEmpty()) {  // WHILE not IF
            wait();  // may wake spuriously or due to another take()
        }
        // When we reach here, we KNOW the queue is non-empty
        var item = items.poll();
        notifyAll();
        return item;
    }
}

Common Mistakes & Pitfalls

• Using if around wait: one wakeup does not prove the condition is true.
• Explaining the loop only with spurious wakeups: competing waiters can also change the condition before this thread reacquires the monitor.
• Testing the condition outside the monitor: the check and transition into the wait set must use the same locking protocol.
• Assuming a notification is stored: a notify call with no waiter does not become a future permit.
• Depending on rarity: correctness follows the API contract, not how often a wakeup pattern appears in tests.