Java.Multithreading.Why are wait() and notify() methods called only in a synchronized block?

Let’s dive into this with clarity and depth:

❓ Why are wait(), notify(), and notifyAll() allowed only inside a synchronized block or method?

---

🔑 Short Answer:

Because wait(), notify(), and notifyAll() operate on the monitor (lock) of an object, and you must hold that lock to use them.

🔐 In Java, Every Object Has a Monitor

When you write:

synchronized (someObject) {
    someObject.wait();
}

You are:

• Acquiring someObject’s monitor (i.e., lock)
• Then calling wait() on it — which releases that same monitor and waits to reacquire it later

🚨 If you don’t hold the lock:

Then calling wait() or notify() would mean:

• You’re trying to manipulate the monitor of an object you don’t control 😬
• That breaks thread safety

⚠️ So Java enforces this:

If you call wait() or notify() outside of a synchronized block/method that locks on the same object, you’ll get:

java.lang.IllegalMonitorStateException

🔁 Why It’s Designed This Way

Method	What it does	Why lock is needed
wait()	Releases the object’s monitor, pauses thread	Must own the monitor to release it
notify()	Signals a waiting thread to resume	Must own the monitor to notify safely
notifyAll()	Signals all waiting threads	Same — must control the monitor

---

🧪 Metaphor: Room with a key

Let’s say:

• The room is an object.
• The key is the monitor (lock).
• wait() means: step outside and wait in the hall, letting someone else in.
• notify() means: tell someone in the hall they can come in.

🔒 If you don’t have the key (not synchronized):

You shouldn’t be controlling who’s allowed in or out — it would be chaotic and unsafe! Java protects you by throwing an exception.

---

✅ Correct Usage Pattern

synchronized (lock) {
    while (!condition) {
        lock.wait();  // OK ✅
    }
    // proceed safely
}

🔁 Summary

Concept	Explanation
Why synchronized?	Because wait() and notify() need to interact with the monitor
What if not?	Java throws IllegalMonitorStateException
What does wait() do?	Releases the lock and pauses thread
Why check condition?	To avoid spurious wakeups and race conditions