Java wait/notify/notifyAll — Stop Deadlocks at 2 AM

/**
 * Demonstrates the fundamental wait/notify contract.
 * Shows the mandatory while-loop pattern and the lock-release behaviour.
 *
 * Run this and watch how the producer thread parks the consumer
 * until data is actually ready — zero busy-waiting.
 */
public class MonitorInternalsDemo {

    private static final Object lock = new Object();
    private static String sharedData = null;       // guarded by 'lock'
    private static boolean dataReady = false;      // condition variable

    public static void main(String[] args) throws InterruptedException {

        // --- CONSUMER THREAD ---
        Thread consumer = new Thread(() -> {
            synchronized (lock) {                   // 1. acquire the monitor
                System.out.println("[Consumer] Lock acquired. Checking condition...");

                // CRITICAL: while — not if — because of spurious wakeups
                // and because another consumer could steal the data first.
                while (!dataReady) {
                    System.out.println("[Consumer] Data not ready. Releasing lock and sleeping...");
                    try {
                        lock.wait();               // 2. atomically: releases lock + parks thread
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); // preserve interrupt flag
                        return;
                    }
                    // 3. After wakeup: lock is re-acquired before we get here.
                    // We MUST re-check dataReady — it may have been consumed already.
                    System.out.println("[Consumer] Woke up. Re-checking condition...");
                }

                // Safe to read: we hold the lock AND the condition is confirmed true.
                System.out.println("[Consumer] Data received: " + sharedData);
            }
        }, "ConsumerThread");

        // --- PRODUCER THREAD ---
        Thread producer = new Thread(() -> {
            try {
                Thread.sleep(1500); // simulate work before data is ready
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }

            synchronized (lock) {                   // must hold lock before notify()
                sharedData = "Order #42 — Double Espresso";
                dataReady = true;
                System.out.println("[Producer] Data prepared. Notifying consumer...");
                lock.notify();                     // wake one waiting thread
            }                                      // lock released here
        }, "ProducerThread");

        consumer.start();
        producer.start();

        consumer.join();
        producer.join();
        System.out.println("[Main] Both threads finished cleanly.");
    }
}

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * A thread-safe bounded queue built with wait/notify.
 * Producers block when full. Consumers block when empty.
 * Uses notifyAll() deliberately — see comment inside offer().
 */
public class BoundedBlockingQueue<T> {

    private final Deque<T> buffer;
    private final int capacity;
    private final Object lock = new Object();

    public BoundedBlockingQueue(int capacity) {
        this.capacity = capacity;
        this.buffer = new ArrayDeque<>(capacity);
    }

    /**
     * Adds an item. Blocks if the buffer is full.
     */
    public void offer(T item) throws InterruptedException {
        synchronized (lock) {
            // Wait until there's space — re-check after every wakeup
            while (buffer.size() == capacity) {
                System.out.printf("[%s] Buffer full (%d/%d). Producer waiting...%n",
                        Thread.currentThread().getName(), buffer.size(), capacity);
                lock.wait();
            }

            buffer.addLast(item);
            System.out.printf("[%s] Produced: %-20s | Buffer size: %d/%d%n",
                    Thread.currentThread().getName(), item, buffer.size(), capacity);

            // notifyAll() instead of notify() because:
            // Both producers AND consumers share this wait-set.
            // A notify() might wake another blocked producer (wrong thread type)
            // leaving a starved consumer sleeping forever.
            lock.notifyAll();
        }
    }

    /**
     * Removes and returns an item. Blocks if the buffer is empty.
     */
    public T poll() throws InterruptedException {
        synchronized (lock) {
            // Wait until there's something to consume
            while (buffer.isEmpty()) {
                System.out.printf("[%s] Buffer empty. Consumer waiting...%n",
                        Thread.currentThread().getName());
                lock.wait();
            }

            T item = buffer.removeFirst();
            System.out.printf("[%s] Consumed: %-20s | Buffer size: %d/%d%n",
                    Thread.currentThread().getName(), item, buffer.size(), capacity);

            lock.notifyAll(); // wake blocked producers now that space exists
            return item;
        }
    }

    // ---------------------------------------------------------------
    // Demo: 2 producers, 3 consumers, capacity 3
    // ---------------------------------------------------------------
    public static void main(String[] args) throws InterruptedException {
        BoundedBlockingQueue<String> queue = new BoundedBlockingQueue<>(3);

        Runnable producerTask = () -> {
            String[] orders = {"Latte", "Espresso", "Cappuccino", "Americano"};
            for (String order : orders) {
                try {
                    queue.offer(order);
                    Thread.sleep(200); // simulate production time
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable consumerTask = () -> {
            for (int i = 0; i < 3; i++) {
                try {
                    queue.poll();
                    Thread.sleep(500); // consumers are slower than producers
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Thread p1 = new Thread(producerTask, "Producer-1");
        Thread p2 = new Thread(producerTask, "Producer-2");
        Thread c1 = new Thread(consumerTask, "Consumer-1");
        Thread c2 = new Thread(consumerTask, "Consumer-2");
        Thread c3 = new Thread(consumerTask, "Consumer-3");

        p1.start(); p2.start();
        c1.start(); c2.start(); c3.start();

        p1.join(); p2.join();
        c1.join(); c2.join(); c3.join();
        System.out.println("[Main] All threads done. Queue size: " + queue.buffer.size());
    }
}

/**
 * Demonstrates the dangerous scenario where notify() causes a missed wakeup
 * and why notifyAll() fixes it.
 *
 * Scenario: Two consumers (waiters for DIFFERENT conditions) share one lock.
 * A producer does notify() — wakes the wrong consumer — deadlock-like stall.
 */
public class NotifyVsNotifyAll {

    private static final Object lock = new Object();
    private static boolean coffeeReady = false;
    private static boolean teaReady = false;

    public static void main(String[] args) throws InterruptedException {

        // Consumer A is waiting for coffee
        Thread coffeeWaiter = new Thread(() -> {
            synchronized (lock) {
                while (!coffeeReady) {
                    System.out.println("[CoffeeWaiter] Waiting for coffee...");
                    try { lock.wait(); } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); return;
                    }
                }
                System.out.println("[CoffeeWaiter] Got coffee! ");
            }
        }, "CoffeeWaiter");

        // Consumer B is waiting for tea
        Thread teaWaiter = new Thread(() -> {
            synchronized (lock) {
                while (!teaReady) {
                    System.out.println("[TeaWaiter] Waiting for tea...");
                    try { lock.wait(); } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); return;
                    }
                }
                System.out.println("[TeaWaiter] Got tea! ");
            }
        }, "TeaWaiter");

        coffeeWaiter.start();
        teaWaiter.start();
        Thread.sleep(500); // let both threads park in wait-set

        // SAFE VERSION — notifyAll() wakes both waiters.
        // Each re-checks their own condition. The right one proceeds.
        synchronized (lock) {
            coffeeReady = true;
            System.out.println("[Barista] Coffee ready. Using notifyAll()...");
            lock.notifyAll();  // try replacing with notify() — tea waiter may never wake
        }

        // Give tea waiter something to wake for too
        Thread.sleep(200);
        synchronized (lock) {
            teaReady = true;
            System.out.println("[Barista] Tea ready. Using notifyAll()...");
            lock.notifyAll();
        }

        coffeeWaiter.join();
        teaWaiter.join();
        System.out.println("[Main] All customers served.");
    }
}

/**
 * Production-grade pattern showing:
 * 1. Correct InterruptedException handling
 * 2. Timeout on wait() to prevent infinite blocking
 * 3. Lock held only for state access — heavy work done outside
 */
public class ProductionSafeWaitNotify {

    private static final Object stateLock = new Object();
    private static volatile boolean orderComplete = false;

    // Maximum time a consumer should wait before giving up (ms)
    private static final long WAIT_TIMEOUT_MS = 3000;

    /**
     * Consumer: waits for order with a timeout.
     * Returns true if order arrived, false if timed out.
     */
    public static boolean waitForOrder() throws InterruptedException {
        long deadline = System.currentTimeMillis() + WAIT_TIMEOUT_MS;

        synchronized (stateLock) {
            while (!orderComplete) {
                long remaining = deadline - System.currentTimeMillis();

                if (remaining <= 0) {
                    System.out.println("[Consumer] Timed out waiting for order.");
                    return false; // did not get the order in time
                }

                System.out.printf("[Consumer] Waiting up to %dms for order...%n", remaining);
                // wait(timeout) — returns when notified OR when timeout expires
                // We re-check the condition (while loop) either way
                stateLock.wait(remaining);
            }
            return true; // condition is confirmed true, lock is held
        }
    }

    /**
     * Producer: does heavy work OUTSIDE the lock, then signals quickly.
     */
    public static void prepareAndSignalOrder() throws InterruptedException {
        // --- Heavy work happens OUTSIDE the synchronized block ---
        System.out.println("[Producer] Preparing order (heavy work)...");
        Thread.sleep(1200); // simulate DB call, I/O, etc. — NOT inside lock
        String preparedOrder = "Flat White x2";  // result computed outside lock

        // --- Minimal critical section: just update state and signal ---
        synchronized (stateLock) {
            orderComplete = true;
            System.out.println("[Producer] Order ready: " + preparedOrder + ". Notifying...");
            stateLock.notifyAll();
        } // lock released immediately after signal
    }

    public static void main(String[] args) throws InterruptedException {
        Thread consumerThread = new Thread(() -> {
            try {
                boolean received = waitForOrder();
                System.out.println("[Consumer] Order received? " + received);
            } catch (InterruptedException e) {
                // CORRECT: restore the interrupt flag, don't swallow it
                Thread.currentThread().interrupt();
                System.out.println("[Consumer] Interrupted. Shutting down.");
            }
        }, "ConsumerThread");

        Thread producerThread = new Thread(() -> {
            try {
                prepareAndSignalOrder();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "ProducerThread");

        consumerThread.start();
        producerThread.start();

        consumerThread.join();
        producerThread.join();
    }
}

// io.thecodeforge — java tutorial

public class WaitQueue {
    private final Object lock = new Object();
    private boolean itemReady = false;

    public void consume() throws InterruptedException {
        synchronized (lock) {
            // WRONG: if (!itemReady) lock.wait();
            // RIGHT:
            while (!itemReady) {
                lock.wait(); // may wake up without notify()
            }
            // itemReady is guaranteed true here
            System.out.println("Consumed item");
            itemReady = false;
        }
    }

    public void produce() {
        synchronized (lock) {
            itemReady = true;
            lock.notifyAll();
        }
    }
}

// io.thecodeforge — java tutorial

public class LostWakeup {
    private final Object lock = new Object();
    private boolean ready = false;

    public void badProducer() {
        synchronized (lock) {
            ready = true;
            // Oops: condition set, but notify() happens AFTER lock release
        }
        // Thread might be interrupted here; waiting thread hasn't started
        // Now this notify() wakes nobody
        synchronized (lock) {
            lock.notify(); // LOST!
        }
    }

    public void correctProducer() {
        synchronized (lock) {
            ready = true;
            lock.notifyAll(); // notification happens atomically with state change
        }
    }
}

// io.thecodeforge — java tutorial

public class PreciseWaitExample {
    private final Object lock = new Object();
    private boolean ready = false;

    public void waitForReady() throws InterruptedException {
        synchronized (lock) {
            long start = System.nanoTime();
            while (!ready) {
                // Wait 2.5ms — rounds to next OS tick
                lock.wait(0, 500_000); 
            }
            long elapsed = System.nanoTime() - start;
            System.out.println("Woke up after " + (elapsed / 1_000_000) + " ms");
        }
    }

    public void signal() {
        synchronized (lock) {
            ready = true;
            lock.notify();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        PreciseWaitExample ex = new PreciseWaitExample();
        new Thread(ex::signal).start();
        ex.waitForReady();
    }
}

// io.thecodeforge — java tutorial

public class CorrectPattern {
    private final Object lock = new Object();
    private boolean condition = false;

    public void waitForCondition() throws InterruptedException {
        synchronized (lock) {
            while (!condition) { // Spurious wakeup safe
                lock.wait();
            }
            // condition is true, proceed safely
        }
    }

    public void signal() {
        synchronized (lock) {
            condition = true;
            lock.notifyAll(); // Safe: wakes all, even if one was wrong
        }
    }
}

// io.thecodeforge — java tutorial
// Notifier must hold the same lock as wait()
public class NotifierExample {
    private final Object lock = new Object();
    private boolean ready = false;

    public void waitForSignal() throws InterruptedException {
        synchronized (lock) {
            while (!ready) { lock.wait(); }
        }
    }

    public void sendSignal() {
        synchronized (lock) {
            ready = true;
            lock.notify(); // Must be inside synchronized
        }
    }
}

// io.thecodeforge — java tutorial
import java.util.concurrent.*;

public class WaitNotifyTest {
    private final Object lock = new Object();
    private boolean condition = false;

    public void test() throws Exception {
        CountDownLatch waiterReady = new CountDownLatch(1);
        ExecutorService exec = Executors.newFixedThreadPool(2);

        exec.submit(() -> { // Waiter
            synchronized (lock) {
                waiterReady.countDown();
                while (!condition) {
                    try { lock.wait(1000); } catch (InterruptedException e) {}
                }
            }
        });

        waiterReady.await(); // Ensure waiter starts first
        exec.submit(() -> { // Notifier
            synchronized (lock) {
                condition = true;
                lock.notify();
            }
        });

        exec.shutdown();
        assert exec.awaitTermination(2, TimeUnit.SECONDS) : "Deadlock!";
    }
}