Waiting for Something to Happen

wait(), notify() and notifyAll() are on Object, alongside the lock from Section 8.3. Every object has all three.

// consumer
synchronized (lock) {
    while (queue.isEmpty()) {
        lock.wait();               // release the lock and step aside
    }
    Job job = queue.removeFirst();
}

// producer
synchronized (lock) {
    queue.add(job);
    lock.notifyAll();              // tell anyone waiting
}

wait() releases the lock. That is the whole difference from sleep, and it is what makes this work at all:

holder: got the lock, now waiting
prober: got in WHILE the holder was waiting
holder: woke up

The waiting thread is in WAITING from Section 14.2, holding nothing, using no processor.

Step four is the one people miss. notify does not hand over the lock. It makes a thread eligible, and there is a gap before it actually runs.

Which is why wait must be in a while loop.

while (queue.isEmpty()) {          // correct
    lock.wait();
}

if (queue.isEmpty()) {             // broken
    lock.wait();
}

Waking up is not a promise that anything happened. Three ways to wake with nothing to do:

An if checks once and never again, so the thread continues believing something that has become false. A while re-checks after every wake, which is correct in all three cases.

notifyAll unless you can prove notify is safe.

notify wakes one thread and you do not get to choose which. That is fine when every waiter wants the same thing and any of them will do.

It breaks as soon as there are two kinds of waiter. In a bounded queue, producers wait for space and consumers wait for items, and both wait on the same lock. notify after adding an item can wake a producer, which re-checks, finds no space, and waits again. The consumer was never told and nothing moves.

notifyAll wakes everyone. The ones with nothing to do loop and wait again, and the right one gets through.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. `wait()` and `sleep()` both pause a thread. What is the difference that matters?

   Show the answer

   wait() releases the lock. sleep() keeps it.

   Verified. A thread holding a lock and sitting in wait() let another thread straight in. A thread holding the same lock and sitting in sleep() made the other thread wait 322 ms for it.

   That is why sleeping inside a lock is usually a bug. Nobody else can get in, including the thread that was going to produce the thing you are waiting for, so the wait can never end.

   The other difference follows from it. wait() is on Object, because it is about a lock. sleep() is static on Thread, because it is about a thread and no lock is involved.

2. Why must `wait()` always be called inside a `while` loop and never inside an `if`?

   Show the answer

   Because waking up is not a promise that anything happened.

   Three ways to wake with nothing to do. A spurious wakeup, which the specification allows with no reason given. notifyAll waking ten threads when only one item arrived. And another thread taking the item between your wakeup and your reacquiring the lock.

   An if checks once, before waiting, and never again. So the thread carries on believing a condition that may now be false, and takes from an empty queue.

   A while re-checks after every wake. If the condition is still false it waits again, which is correct in all three cases.

3. When is `notify()` safe, and why is `notifyAll()` the usual advice?

   Show the answer

   notify() wakes one waiting thread and you do not choose which. It is safe only when every waiting thread is waiting for the same condition and any one of them can handle it.

   The moment there are two kinds of waiter, it breaks. Producers waiting for space and consumers waiting for items are on the same lock, so notify can wake a producer when an item arrived. That producer re-checks, sees no space, and waits again. The consumer was never told, and everything stops.

   notifyAll wakes all of them. The ones with nothing to do go back to waiting, because they are in a while loop.

   It costs more and it cannot deadlock this way, so it is the right default.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises100 pointsabout 95 minutes

public class Holding {
    static final Object lock = new Object();

    public static void main(String[] args) throws Exception {
        // TODO: a thread that takes the lock and then SLEEPS for 400 ms.
        //       A second thread that tries to take the lock. Time how long it waits.
        // TODO: the same with wait(400) instead of sleep. Time it again.
        // TODO: print the first thread's state in both cases while it is paused
        // TODO: say why wait() lives on Object and sleep() on Thread
    }
}

import java.util.*;

public class WhileNotIf {
    static final Object lock = new Object();
    static final LinkedList<Integer> queue = new LinkedList<>();

    public static void main(String[] args) throws Exception {
        // TODO: THREE consumers, each waiting for an item, using `if` not `while`.
        //       One producer that adds ONE item and calls notifyAll.
        //       Predict what happens. Then run it.
        // TODO: change the if to a while and run again
        // TODO: with the if version, catch the exception and say exactly what
        //       the third consumer did wrong
        // TODO: name the three reasons a thread can wake with nothing to do
    }
}

public class TooEarly {
    static final Object lock = new Object();
    static boolean ready = false;

    public static void main(String[] args) throws Exception {
        // TODO: write it WRONG on purpose: the consumer checks the flag outside
        //       the synchronized block, then enters and waits. The producer sets
        //       the flag and notifies in between. Use sleeps to force the order.
        // TODO: show the consumer waiting forever
        // TODO: fix it by putting the check and the wait in ONE synchronized block
        // TODO: say why the fix works, in terms of who holds the lock
    }
}

import java.util.*;
import java.util.concurrent.*;

public class ThrowAway {
    // TODO: write a bounded buffer BY HAND with wait and notifyAll:
    //   put(item) waits while it is full
    //   take() waits while it is empty
    //   both in while loops, both notifying afterwards

    public static void main(String[] args) throws Exception {
        // TODO: two producers and two consumers against your version. Run it a while.
        // TODO: rewrite the whole thing with ArrayBlockingQueue. Count the lines.
        // TODO: say which parts of your hand written version were the risky ones
        // TODO: why can notify() not be used safely in your version?
    }
}