What is a deadlock? What are the four conditions, and how do you prevent it?

Question

IT Interview Practice · Accepted Answer

**A deadlock is a state where two or more threads each wait forever for a resource the others hold, so none can proceed.** It requires four conditions to hold simultaneously (Coffman conditions).

## The four conditions

1. **Mutual exclusion** — a resource is held exclusively.
2. **Hold and wait** — a thread holds one resource while waiting for another.
3. **No preemption** — resources can't be forcibly taken away.
4. **Circular wait** — a cycle of threads each waiting on the next.

Break any one and deadlock is impossible.

```text
Thread 1 holds A, wants B ─┐
                           ├─ circular wait → deadlock
Thread 2 holds B, wants A ─┘
```

## Example and fix

```python
# DEADLOCK: threads lock in opposite orders
def t1():
    with lockA:
        with lockB: ...     # T1: A then B
def t2():
    with lockB:
        with lockA: ...     # T2: B then A  ← cycle!

# FIX: impose a global lock ordering (always A before B)
def safe():
    with lockA:
        with lockB: ...     # everyone acquires in the same order
```

## Prevention & detection

- **Lock ordering**: always acquire locks in a consistent global order — breaks circular wait.
- **Timeouts / try-lock**: `tryAcquire(timeout)`, back off and retry — breaks hold-and-wait.
- **Single coarse lock** or lock-free structures avoid the problem entirely.
- **Detection**: a watchdog builds a wait-for graph and looks for cycles, then kills/restarts a victim.

## Why it matters

Deadlocks freeze systems silently — no crash, just hung requests. Naming the four conditions shows you can reason about *why* it happens and pick a targeted prevention (usually consistent lock ordering), rather than sprinkling locks and hoping.

The four conditions

Example and fix

Prevention & detection

Why it matters

Related questions