LockSupport.park() vs wait()?

• park() blocks the current thread by consuming its permit. If the permit is already available (set by a prior unpark()), park() returns immediately without blocking.
• unpark(thread) sets the target thread's permit to 1. If the thread is currently parked, it unblocks. If it is not yet parked, the permit is stored and the next park() returns immediately.
• wait() releases the monitor lock and blocks until notify() or notifyAll() is called. The calling thread must hold the monitor (be inside a synchronized block), otherwise IllegalMonitorStateException is thrown.
• notify() wakes one arbitrary thread waiting on the monitor. If no thread is waiting, the notification is silently lost.
• Key difference – unpark() before park() stores the permit (signal not lost). notify() before wait() is permanently lost (signal lost).
• AQS – AbstractQueuedSynchronizer, the foundation of ReentrantLock, CountDownLatch, Semaphore, and other j.u.c utilities, is built on park/unpark because they are more flexible and do not require monitor ownership.

What is LockSupport.park() and unpark()?

LockSupport provides thread-blocking primitives based on a binary permit. Each thread has exactly one permit, which is either 0 (not available) or 1 (available). park() consumes the permit: if it is 1, park() sets it to 0 and returns immediately. If it is 0, park() blocks until unpark() is called. unpark(thread) sets the target thread's permit to 1 and unblocks it if it is currently parked.

package com.bank.concurrency;

import java.util.concurrent.locks.LockSupport;

public class ParkUnparkDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            System.out.println("Rajesh: before park");
            LockSupport.park();  // blocks until permit is available
            System.out.println("Rajesh: after park, resumed!");
        }, "Rajesh");
        worker.start();
        Thread.sleep(100);
        System.out.println("Manager: calling unpark");
        LockSupport.unpark(worker);  // sets permit, worker resumes
    }
}

Rajesh: before park
Manager: calling unpark
Rajesh: after park, resumed!

Why is unpark() before park() not lost?

The permit is stored. If unpark() is called before the target thread calls park(), the permit is set to 1 and the subsequent park() consumes it immediately without blocking.

package com.bank.concurrency;

import java.util.concurrent.locks.LockSupport;

public class UnparkBeforeParkDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            try { Thread.sleep(200); } catch (InterruptedException e) { return; }
            LockSupport.park();  // permit already set: returns IMMEDIATELY
            System.out.println("Rajesh: did not block! Permit was waiting.");
        }, "Rajesh");
        worker.start();
        LockSupport.unpark(worker);  // set permit BEFORE park() is called
        worker.join();
    }
}

Why is notify() before wait() lost?

With wait/notify, there is no stored signal. If notify() is called when no thread is waiting on the monitor, the notification is silently discarded and can never be recovered.

package com.bank.concurrency;

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

    public static void main(String[] args) throws InterruptedException {
        // Thread-1 notifies before Thread-2 waits
        new Thread(() -> {
            synchronized (lock) {
                lock.notify();  // nobody waiting: notification LOST!
            }
        }, "Notifier").start();

        Thread.sleep(100);  // ensure notify runs first

        new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();  // waits FOREVER: the notify was lost
                } catch (InterruptedException e) { }
            }
        }, "Waiter").start();
        // Waiter thread is stuck forever
    }
}

How is park/unpark different from wait/notify?

| Feature | park/unpark | wait/notify |
|---|---|---|
| Lock required? | No | Yes (synchronized) |
| Signal before wait? | NOT lost (permit stored) | LOST permanently |
| Target thread | unpark(specificThread) | notify() wakes any one |
| Spurious wakeup? | Yes (must check condition) | Yes (must check condition) |
| IllegalMonitorStateException? | Never | If not in synchronized |
| Thread dump state | WAITING (parking) | WAITING (on object monitor) |
| Used by | AQS, ReentrantLock, Latch | Classic monitor pattern |

How does AQS use park/unpark?

AbstractQueuedSynchronizer maintains a CLH queue of waiting threads. When a thread fails to acquire the lock, it is added to the queue and parked via LockSupport.park(). When the lock is released, the next thread in the queue is unparked via LockSupport.unpark(nextThread). This design does not require any monitor lock, can target specific threads, and never loses signals.

// Simplified AQS acquire logic:
// if (!tryAcquire(arg)) {
//     enqueue(currentThread);
//     LockSupport.park(this);   // block until unparked
// }
// Simplified AQS release logic:
// if (tryRelease(arg)) {
//     Thread next = dequeue();
//     LockSupport.unpark(next);  // wake specific next thread
// }

What are common mistakes?

The most common mistake is forgetting that park() can return spuriously. Just like wait(), park() may return without unpark() being called. Always check the condition in a loop.

// WRONG: assuming park() only returns on unpark()
LockSupport.park();
processTask();  // may run even if unpark was not called!

// CORRECT: check condition in a loop
while (!taskReady) {
    LockSupport.park();
}
processTask();

What are common interview follow-up questions?

• Can you use park/unpark to implement a simple mutex? Yes, but it is complex and error-prone. Use ReentrantLock instead, which is built on AQS (which uses park/unpark internally).
• Does park() respond to interrupts? Yes. If the thread is interrupted while parked, park() returns and the interrupt status is set. Check Thread.interrupted() after park().