Understanding Java Thread Deadlocks: 5 Common Scenarios and How to Fix Them

In Java, a thread deadlock occurs when two or more threads each hold a resource the other needs and wait for the other to release it, causing all involved threads to block permanently.

The article visualizes a deadlock situation where Thread‑A holds LockA and waits for LockB, while Thread‑B holds LockB and waits for LockA. The diagram shows the circular wait and the resulting state where both threads wait forever, preventing the program from progressing.

Result: both Thread‑A and Thread‑B remain in an endless waiting state, and the program cannot continue execution.

Solution 1 – Consistent lock ordering : Ensure all threads acquire locks in the same order, e.g., always lock the object with the smaller identity hash code first. Example:

if (System.identityHashCode(lockA) < System.identityHashCode(lockB)) {
    synchronized (lockA) {
        synchronized (lockB) {
            // critical section
        }
    }
} else {
    synchronized (lockB) {
        synchronized (lockA) {
            // critical section
        }
    }
}

Solution 2 – Minimize nested locks : Reduce the number of locks held simultaneously; avoid patterns like “hold A then request B” that create chain‑waiting.

Solution 3 – Shrink lock scope : Limit synchronized blocks to the smallest possible code that actually protects shared data, keeping I/O, RPC, database access, and heavy computation outside the locked region.

Solution 4 – Use timed locks : Apply Lock.tryLock(timeout) to give up after a timeout, preventing indefinite waiting.

Solution 5 – Design lock‑free or low‑lock structures : Prefer concurrent collections, atomic classes, message queues, CAS operations, or segmented locks instead of coarse‑grained mutexes.