Understanding Deadlocks: Causes, Conditions, and Prevention Strategies

Deadlock Interview Question (What is a deadlock, causes, necessary conditions)

What is a deadlock?

A deadlock occurs when two or more processes compete for resources and become stuck such that none can proceed without external intervention. For example, thread A locks resource a then tries to lock b, while thread B locks b then tries to lock a, creating a circular wait.

Causes of deadlock

Deadlocks arise mainly from two factors: competitive resources and illegal ordering of resource acquisition.

Competitive resources

Preemptible resources : can be taken away from a process (e.g., CPU, main memory).

Non‑preemptible resources : once allocated they cannot be forcibly reclaimed until the owning process releases them (e.g., tape drives, printers).

Competition for non‑preemptible resources (e.g., a single printer used by multiple processes) can cause deadlock.

Competition for temporary resources such as interrupts, signals, messages, or buffer slots; improper ordering of message passing can also lead to deadlock.

Illegal ordering of process progression

If process P1 holds resource R1 and process P2 holds resource R2, and each subsequently requests the other's resource, both block, forming a deadlock.

Four necessary conditions for deadlock

Mutual exclusion : a resource can be used by only one process at a time.

Hold and wait : a process holding one or more resources may request additional ones.

No preemption : resources cannot be forcibly taken away from a process.

Circular wait : a closed chain of processes exists, each waiting for a resource held by the next process in the chain.

Basic methods to handle deadlock

Prevention

Allocate all required resources to a process in a single request; if any are unavailable, deny the entire allocation (breaks the hold‑and‑wait condition).

Make resources preemptible so a process can release held resources when it cannot obtain the remaining ones (breaks the no‑preemption condition).

Enforce an ordered resource‑allocation scheme: assign a numeric order to each resource type and require processes to request resources only in increasing order and release them in reverse order (breaks circular wait).

Lock ordering example

When multiple locks must be obtained, designing a consistent acquisition order prevents circular wait. The diagrams below illustrate lock ordering before and after applying a fixed order.

Timeout abandonment

Using the Lock.tryLock(long time, TimeUnit unit) method allows a thread to wait for a lock only for a specified duration; if the timeout expires, the thread can release any already‑acquired locks, avoiding indefinite blocking.

Avoidance (performance‑aware strategies)

Apply weak restrictions that prevent deadlock while preserving acceptable system performance.

Before granting a resource request, compute whether the resulting state would remain safe; if not, postpone the allocation.

The Banker’s algorithm formalises this safety check. It defines: Resource vector – total amount of each resource type in the system. Available vector – amount of each resource type currently unallocated. Claim matrix – maximum demand of each process for each resource. Allocation matrix – current allocation of resources to each process.

A state is safe if there exists at least one sequence of process completions that does not lead to deadlock. The algorithm simulates granting a request, updates the state, and checks for safety before actually allocating the resources.

Detection

Assign a unique identifier to each process and each resource.

Construct a resource‑allocation graph and a wait‑for graph; a cycle in either graph indicates a deadlock.

Recovery

Preempt resources from other processes and give them to the deadlocked process.

Terminate one or more processes (preferably the least costly in terms of priority, runtime, or importance) to break the circular wait.

Deadlock detection tools

jstack : a JVM tool that prints stack traces of a Java process, useful for capturing thread snapshots and identifying deadlocked threads.

JConsole : a lightweight JDK monitoring tool that visualises JVM resource usage and can help spot thread contention and deadlocks.