Deadlock vs livelock vs starvation?

• Deadlock – two or more threads are permanently blocked, each waiting for a lock held by the other. Thread state: BLOCKED. CPU usage: near zero. No exception thrown. Detected by jstack (prints "Found Java-level deadlock") and ThreadMXBean.findDeadlockedThreads().
• Livelock – threads are RUNNING (not blocked) but make no useful progress. They continuously change state in response to each other without advancing. Thread state: RUNNABLE. CPU: 100%. Throughput: zero. Harder to detect because jstack does not report it as a deadlock.
• Starvation – a thread is denied access to a resource because other threads always take priority. Common with non-fair locks, low thread priority, or reader-heavy ReadWriteLock. The thread may be WAITING or BLOCKED but never gets served.
• Detection – deadlock: automatic (jstack, ThreadMXBean). Livelock: high CPU + zero throughput (manual correlation). Starvation: per-thread wait time monitoring (one thread's wait time is much longer than others).

What is a deadlock?

Deadlock occurs when two or more threads form a circular chain of lock dependencies. Thread-1 holds lock-A and waits for lock-B. Thread-2 holds lock-B and waits for lock-A. Neither can proceed.

package com.bank.concurrency;

import java.math.BigDecimal;

public class DeadlockDemo {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lockA) {
                try { Thread.sleep(50); } catch (InterruptedException e) { }
                synchronized (lockB) { System.out.println("Thread-1 done"); }
            }
        }, "Rajesh-Transfer").start();

        new Thread(() -> {
            synchronized (lockB) {
                try { Thread.sleep(50); } catch (InterruptedException e) { }
                synchronized (lockA) { System.out.println("Thread-2 done"); }
            }
        }, "Priya-Transfer").start();
        // DEADLOCK: Rajesh holds A, waits for B. Priya holds B, waits for A.
    }
}

What is a livelock?

Livelock occurs when threads continuously react to each other without making progress. Both threads are actively running (RUNNABLE state) and consuming CPU, but neither advances toward completion.

package com.bank.concurrency;

import java.util.concurrent.locks.ReentrantLock;

public class LivelockDemo {
    private static final ReentrantLock lockA = new ReentrantLock();
    private static final ReentrantLock lockB = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                lockA.lock();
                if (lockB.tryLock()) {
                    try { System.out.println("Thread-1 done"); return; }
                    finally { lockB.unlock(); lockA.unlock(); }
                }
                lockA.unlock();  // give up, retry
                // Without backoff: both threads retry in sync → livelock!
            }
        }, "Worker-1").start();

        new Thread(() -> {
            while (true) {
                lockB.lock();
                if (lockA.tryLock()) {
                    try { System.out.println("Thread-2 done"); return; }
                    finally { lockA.unlock(); lockB.unlock(); }
                }
                lockB.unlock();  // give up, retry
            }
        }, "Worker-2").start();
        // Both keep acquiring/releasing in sync: LIVELOCK
        // Fix: add random backoff: Thread.sleep(random * 2^attempt)
    }
}

How do you detect each one?

| Hazard | Thread state | CPU | Detection method |
|---|---|---|---|
| Deadlock | BLOCKED | Near 0% | jstack: "Found Java-level deadlock" |
| Livelock | RUNNABLE | 100% | CPU + zero throughput correlation |
| Starvation | WAITING/BLOCKED | Varies | Per-thread wait time monitoring |

How do you fix each one?

• Deadlock: consistent lock ordering (always acquire lock-A before lock-B), tryLock with timeout, or avoid nested locks entirely.
• Livelock: random backoff between retries. Thread.sleep(ThreadLocalRandom.current().nextLong(10, 100)) breaks the synchronization between competing threads.
• Starvation: fair locks (new ReentrantLock(true)), equal thread priorities, or redesigning the access pattern.

What are common interview follow-up questions?

• Can ThreadMXBean detect livelock? No. findDeadlockedThreads() only detects threads in BLOCKED state waiting for locks. Livelock threads are RUNNABLE.
• Can a deadlock resolve itself? No. Without external intervention (kill thread, timeout), deadlock is permanent.