Deadlock occurs when processes are blocked waiting for resources held by other processes in a circular chain. There are four necessary conditions for deadlock: mutual exclusion, hold and wait, no preemption, and circular wait. Approaches to handle deadlock include prevention, avoidance, and detection/recovery. Prevention methods modify resource allocation to break one of the conditions, avoidance methods allocate resources in a way that avoids unsafe states that could lead to deadlock, and detection/recovery finds and resolves deadlocks after they occur.

1. Deadlock
Prevention and Avoidance

2. Deadlock in real life..

3. Deadlock is:
 A set of blocked processes each holding a resource and
waiting to acquire a resource held by another process in the
set.

4. There are three policy conditions that must hold for a deadlock to be
possible (the “necessary conditions”):
1. Mutual Exclusion
2. Hold-and-Wait
3. No Preemption
4. Circular Wait
The (4) Conditions for Deadlock

5.  Deadlock occurs if and only if the circular
wait condition is unresolvable
 The circular wait condition is unresolvable
if the first 3 policy conditions hold
 So the 4 conditions taken together constitute
necessary and sufficient conditions for
deadlock
The Conditions for Deadlock

6. Approaches to handle deadlock
 Deadlock Prevention
 Deadlock Avoidance
 Deadlock Detection and
Recovery

7. 1. A process acquires all the needed resources
simultaneously before it begins its
execution, therefore breaking the hold and
wait condition.
Deadlock Prevention
E.g. In the dining philosophers’ problem, each philosopher is required to pick up both
forks at the same time. If he fails, he has to release the fork(s) (if any) he has
acquired.

8. 2. All resources are assigned unique numbers. A
process may request a resource with a unique
number I only if it is not holding a resource with a
number less than or equal to I and therefore
breaking the circular wait condition.
E.g. In the dining philosophers problem, each philosopher is required to pick a
fork that has a larger id than the one he currently holds. That is, philosopher P5
needs to pick up fork F5 and then F1; the other philosopher Pi should pick up fork
Fi followed by Fi-1.

9. 3. Each process is assigned a unique priority number.
The priority numbers decide whether process Pi
should wait for process Pj and therefore break the
non-preemption condition.
4. Practically it is impossible to provide a method to
break the mutual exclusion condition since most
resources are intrinsically non-sharable, e.g., two
philosophers cannot use the same fork at the same
time.

10. Deadlock Avoidance
Avoid actions that may lead to deadlock.
Think of it as a safe state moving from one state to another as
instruction is executed.
We can avoid the situation of deadlock by :
1.Safe state
2. Bankers Algorithm
3.Resource allocation graph

11. Safe state
" ■ System is in safe state if there exists a safe sequence of all
processes."
When a process requests an available resource, system must decide if
immediate allocation leaves the system in a safe state.
■ Sequence <P1, P2, …, Pn> is safe if for each Pi, the resources that Pi can still request can be
satisfied by currently available resources + resources held by all the Pj, with j<I."
● If Pi resource needs are not immediately available, then Pi can wait until all Pj have finished.“
● When Pj is finished, Pi can obtain needed resources, execute, return allocated resources, and
terminate. "
● When Pi terminates, Pi+1 can obtain its needed resources, and so on. "

12. A resource allocation graph is generally used to avoid deadlocks. If there are no cycles in
the resource allocation graph, then there are no deadlocks. If there are cycles, there may
be a deadlock. If there is only one instance of every resource, then a cycle implies a
deadlock.
Consider the image with calm edges as below:
If R2 is allocated to p2 and if P1 request for R2, there will be a deadlock.
Resource allocation graph

13. Example: The banker knows that all 4 clients need 22
units together, but he has only total 10 units
Banker’s Algorithm:
ADAM 0 6
EVE 0 5
JOE 0 4
MARY 0 7
ADAM 1 6
EVE 1 5
JOE 2 4
MARY 4 7
ADAM 1 6
EVE 2 5
JOE 2 4
MARY 4 7
The Banker algorithm, sometimes referred to as the detection algorithm, is a resource
allocation and deadlock avoidance algorithm developed by Edsger Dijkstra that tests for
safety by simulating the allocation of predetermined maximum possible amounts of all
resources, and then makes an "s-state" check to test for possible deadlock conditions
for all other pending activities, before deciding whether allocation should be allowed to
continue.

14. Data Structures for the Banker’s
Algorithm
• Available: Vector of length m.
If available [j] = k, there are k instances of resource type Rj available.
• Max: n x m matrix. If Max [i,j] = k, then process Pi may request at most
k instances of resource type Rj.
• Allocation: n x m matrix. If Allocation[i,j] = k then Pi is currently
allocated k instances of Rj.
• Need: n x m matrix. If Need[i,j] = k, then Pi may need k more instances
of Rj to complete its task.
Need [i,j] = Max[i,j] – Allocation [i,j].
Let n = number of processes, and m = number of resources types.

15. Safety Algorithm
1. Let Work and Finish be vectors of length m and n,
respectively. Initialize: Work = Available Finish [i] =
false for i = 1,2, …, n.
2. Find and i such that both: (a) Finish [i] = false (b)
Needi Work If no such i exists, go to step 4.
3. Work = Work + Allocationi Finish[i] = true go to step 2
4. If Finish [i] == true for all i, then the system is in a safe
state.

16. Requesti = request vector for process Pi.
Requesti [ j ] == k means that process Pi wants k instances of resource type Rj.
1. If Requesti Needi go to step 2. Otherwise, raise error condition, since process
has exceeded its maximum claim
2. If Requesti Available, go to step 3. Otherwise Pi must wait, since resources are
not available.
3. Test to allocate requested resources to Pi by modifying the state as follows:
Available = Available - Requesti;
Allocationi = Allocationi + Requesti;
Needi = Needi – Requesti;
• If safe == the resources are allocated to Pi.
• If unsafe == Pi must wait, and the old resource-allocation state is restored
Resource-Request Algorithm for Process Pi