Deadlocks — Prevention, Avoidance, Banker's Algorithm

🎯 Learning Objectives

• Identify the four necessary conditions for deadlock
• Draw and interpret Resource Allocation Graphs
• Apply Banker's Algorithm to determine safe states
• Compare deadlock prevention, avoidance, detection, and recovery

1. Deadlock Characterization

1.1 Intuition

1.2 Four Necessary Conditions

1.3 Resource Allocation Graph (RAG)

2. Deadlock Prevention

Circular Wait Prevention: Resource Ordering

c
// Define a global total order: R1 < R2 < R3 < ...
// Every process must request resources in increasing order
// WRONG (potential deadlock):
void thread1() {
    lock(mutex1);  // R1
    lock(mutex2);  // R2
}
void thread2() {
    lock(mutex2);  // R2
    lock(mutex1);  // R1 - wait! thread1 holds R1
}
// CORRECT (prevents circular wait):
void thread1() {
    lock(mutex1);  // Lower order first
    lock(mutex2);  // Higher order
}
void thread2() {
    lock(mutex1);  // Same order
    lock(mutex2);
}

3. Deadlock Avoidance (Banker's Algorithm)

3.1 Intuition

3.2 Data Structures

3.3 Safety Algorithm

pseudo
1. Work = Available, Finish[i] = False for all i
2. Find i such that Finish[i] == False && Need[i] <= Work
3. If found: Work += Allocation[i], Finish[i] = True, goto 2
4. If all Finish[i] == True → system is SAFE

3.4 Worked Example 1

3.5 Worked Example 2: Request Evaluation

1. Check: Request ≤ Need? (1,0,2) ≤ (1,2,2) ✓
2. Check: Request ≤ Available? (1,0,2) ≤ (3,3,2) ✓
3. Pretend allocate:

1. Check safety:

3.6 Worked Example 3: Unsafe State

4. Deadlock Detection

4.1 Detection Algorithm (Single Instance)

4.2 Detection Algorithm (Multi-Instance)

pseudo
1. Work = Available
2. For all processes with Allocation[i] == 0, Finish[i] = True
3. Find i: Finish[i] == False && Request[i] <= Work
4. If found: Work += Allocation[i], Finish[i] = True, goto 3
5. If any Finish[i] == False → deadlocked

5. Deadlock Recovery

6. 📐 Key Formulas / Concepts

7. 📝 Practice Questions

Q1: List the four necessary conditions for deadlock. Which one does resource ordering prevent?

Answer: Mutual Exclusion, Hold and Wait, No Preemption, Circular Wait. Resource ordering prevents Circular Wait. Q2: Consider a system with 5 processes and resource A (10 instances). Allocation: P0:3, P1:2, P2:4, P3:1, P4:0. Available:0. All processes need 5 max. Is there deadlock?

Answer: Total allocated = 3+2+4+1+0 = 10. Available = 0. Need: P0=2, P1=3, P2=1, P3=4, P4=5. With Available=0, none can proceed → Deadlock (all four processes P0-P3 are blocked waiting for resources held by each other). Q3: Explain the difference between deadlock prevention and deadlock avoidance.

Answer: Prevention ensures at least one of the four conditions never holds (static design). Avoidance allows deadlock-prone conditions but dynamically checks each resource request against a safety criterion (like Banker's) before granting it. Prevention is simpler but more restrictive; avoidance gives better resource utilization. Q4: In Banker's algorithm, what is a safe state? Give an example of an unsafe state that is not deadlocked.

Answer: A safe state has at least one sequence where each process can eventually finish. An unsafe state has no such sequence but is not yet deadlocked — processes can still execute. Example: If a process holds one unit and needs two more, but only one is left in the pool, the system is unsafe (can't guarantee progress) but not deadlocked (no circular wait yet). Q5: How does a wait-for graph differ from a Resource Allocation Graph?

Answer: A wait-for graph shows only processes (edges P1→P2 means P1 is waiting for a resource held by P2). RAG shows both processes and resources. The wait-for graph is a simplified view derived from RAG by removing resource nodes and condensing paths. A cycle in either indicates possible deadlock.

8. 🔗 Cross-References

• Week 5 - Synchronization: Mutex locking patterns that cause deadlocks
• Week 4 - Priority Scheduling: Priority inversion can be mitigated with priority inheritance
• BSCS4021 (Advanced Algorithms): Cycle detection, graph algorithms Join Discord PreviousSynchronizationNextMemory Management