Coordination: wait/notify, suspend/resume, interrupts

Guarded blocks: waiting for a condition

Sometimes a thread must wait until another thread changes shared state — a consumer must wait for the producer. Busy-waiting in a while (!ready) {} loop wastes the CPU. The cooperative tools are Object.wait(), notify(), and notifyAll(). They are methods on Object and must be called while holding that object's monitor (inside a synchronized block on the same object), or you get IllegalMonitorStateException.

• wait() releases the lock and parks the thread until it is notified.
• notify() wakes one waiting thread; notifyAll() wakes all of them. The woken thread must re-acquire the lock before returning from wait().

The canonical guarded block always waits in a while loop, never an if, to defend against spurious wakeups and stale conditions:

synchronized (lock) {
    while (!ready) {        // while, NOT if
        lock.wait();         // releases lock, sleeps until notified
    }
    // ... condition is now true; act on it ...
}

The notifying side mutates the state and signals while holding the same lock:

synchronized (lock) {
    ready = true;
    lock.notifyAll();   // wake the waiters
}

Cooperative suspend/resume — the Greenhouse Part 2 pattern

The project must suspend and resume a whole collection of running event threads. The wrong way is the deprecated Thread.suspend() / Thread.resume(): suspend() freezes a thread without releasing its locks, so any thread needing those locks blocks forever — a classic deadlock, which is exactly why those methods are deprecated.

The correct, cooperative pattern is a guarded block driven by a flag: the thread checks a suspended flag at a safe point and wait()s while it is set; a resume() clears the flag and notifyAll()s.

class SuspendableEvent implements Runnable {
    private boolean suspended = false;
    private final Object monitor = new Object();

    public void run() {
        while (true) {
            synchronized (monitor) {
                while (suspended) {     // park at a safe point
                    try { monitor.wait(); }
                    catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
            }
            doOneStep();
        }
    }
    public void suspend() { synchronized (monitor) { suspended = true; } }
    public void resume() {
        synchronized (monitor) { suspended = false; monitor.notifyAll(); }
    }
}

interrupt() and join()

interrupt() is the polite way to ask a thread to stop. It sets the thread's interrupt status; a thread blocked in wait(), sleep(), or join() throws InterruptedException so it can clean up and exit. A compute-bound thread should poll Thread.currentThread().isInterrupted() and bail out. The idiom on catching InterruptedException is to restore the flag (Thread.currentThread().interrupt()) unless you are the thread's top level, so callers can see it.

join() makes one thread wait for another to finish: t.join() blocks the caller until t terminates — the standard way to wait for worker threads before reading their results.