Introduction of Deadlock in Operating System

A process in operating system uses resources in the following way. 

1. Requests a resource 
2. Use the resource 
3. Releases the resource 

A deadlock is a situation where a set of processes are blocked because each process is holding a resource and waiting for another resource acquired by some other process. 

Consider an example when two trains are coming toward each other on the same track and there is only one track, none of the trains can move once they are in front of each other. A similar situation occurs in operating systems when there are two or more processes that hold some resources and wait for resources held by other(s). For example, in the below diagram, Process 1 is holding Resource 1 and waiting for resource 2 which is acquired by process 2, and process 2 is waiting for resource 1. 

Examples Of Deadlock

1. The system has 2 tape drives. P1 and P2 each hold one tape drive and each needs another one.
2. Semaphores A and B, initialized to 1, P0, and P1 are in deadlock as follows:

• P0 executes wait(A) and preempts.
• P1 executes wait(B).
• Now P0 and P1 enter in deadlock.

P0	P1
wait(A);	wait(B)
wait(B);	wait(A)

       3.  Assume the space is available for allocation of 200K bytes, and the following sequence of events occurs.

P0	P1
Request 80KB;	Request 70KB;
Request 60KB;	Request 80KB;

       Deadlock occurs if both processes progress to their second request.  

Deadlock can arise if the following four conditions hold simultaneously (Necessary Conditions) 

Mutual Exclusion: Two or more resources are non-shareable (Only one process can use at a time) 
Hold and Wait: A process is holding at least one resource and waiting for resources. 
No Preemption: A resource cannot be taken from a process unless the process releases the resource. 
Circular Wait: A set of processes waiting for each other in circular form. 

Methods for handling deadlock
There are three ways to handle deadlock 
1) Deadlock prevention or avoidance:

Prevention:

The idea is to not let the system into a deadlock state. This system will make sure that above mentioned four conditions will not arise. These techniques are very costly so we use this in cases where our priority is making a system deadlock-free.
One can zoom into each category individually, Prevention is done by negating one of the above-mentioned necessary conditions for deadlock. Prevention can be done in four different ways:

       1. Eliminate mutual exclusion                                        3. Allow preemption

       2. Solve hold and Wait                                                   4. Circular wait Solution           

Avoidance:
Avoidance is kind of futuristic. By using the strategy of “Avoidance”, we have to make an assumption. We need to ensure that all information about resources that the process will need is known to us before the execution of the process. We use Banker’s algorithm (Which is in turn a gift from Dijkstra) to avoid deadlock. 

In prevention and avoidance, we get the correctness of data but performance decreases.

2) Deadlock detection and recovery: If Deadlock prevention or avoidance is not applied to the software then we can handle this by deadlock detection and recovery. which consist of two phases:

1.  In the first phase, we examine the state of the process and check whether there is a deadlock or not in the system.
2.  If found deadlock in the first phase then we apply the algorithm for recovery of the deadlock.

In Deadlock detection and recovery, we get the correctness of data but performance decreases.

3) Deadlock ignorance: If a deadlock is very rare, then let it happen and reboot the system. This is the approach that both Windows and UNIX take. we use the ostrich algorithm for deadlock ignorance.

In Deadlock, ignorance performance is better than the above two methods but the correctness of data.

Safe State:

A safe state can be defined as a state in which there is no deadlock. It is achievable if:

• If a process needs an unavailable resource, it may wait until the same has been released by a process to which it has already been allocated. if such a sequence does not exist, it is an unsafe state.
• All the requested resources are allocated to the process.
  

Exercise:
  1) Suppose n processes, P1, …. Pn shares m identical resource units, which can be reserved and released one at a time. The maximum resource requirement of process Pi is Si, where Si > 0. Which one of the following is a sufficient condition for ensuring that deadlock does not occur? (GATE CS 2005) 

(A) A 
(B) B 
(C) C 
(D) D 

For the solution, see Question 4 of https://www.geeksforgeeks.org/operating-systems-set-16/

See QUIZ ON DEADLOCK for more questions. 

References:
http://www2.latech.edu/~box/os/ch07.pdf
http://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/7_Deadlocks.html

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above

My Personal Notes arrow_drop_up

Save