Question

I’ve read many docs about thread states, some of them tells that there is two different states: blocked (before synchronized) and wait (if calls wait), some others are telling that there is only one state: wait. Moreover, some docs telling that you should call notify() for every wait() and if you don’t then threads waiting() will never be eligible for execution even if monitor is unlocked.

Answer 1

From you last sentence I see you don’t fully understand the difference between synchronized and wait()/notify().

Basically, monitor has lock and condition. It’s almost orthogonal concepts.

• When thread enters a synchronized block, it acquires a lock. When thread leaves that block, it releases a lock. Only one thread can have a lock on a particular monitor.

• When thread having a lock calls wait(), it releases a lock and starts waiting on its condition. When thread having a lock calls notify(), one of the threads (all threads in the case of notifyAll()) waiting on the condition becomes eligible for execution (and starts waiting to acquire a lock, since notifying thread still has it).

So, waiting to acquire a lock (Thread.State.BLOCKED) and waiting on the monitor’s condition (Thread.State.WAITING) are different and independent states.

This behaviour becames more clear if you look at Lock class – it implements the same synchronization primitives as synchronized block (with some extensions), but provides clear distinction between locks and conditions.