DEADLOCK

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 same track and there is only
one track, none of the trains can move once they are
in front of each other. 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.
#DEADLOCK CHARACTERIZATION
Necessary conditions for Deadlocks
1.Mutual Exclusion: One or more than one
resource are non-sharable (Only one process can
use at a time).
2. Hold and Wait
A process waits for some resources while
holding another resource at the same
time.
3.No preemption
The process which once scheduled will be
executed till the completion. No other
process can be scheduled by the scheduler
meanwhile.
4.Circular Wait
All the processes must be waiting for the
resources in a cyclic manner so that the
last process is waiting for the resource
which is being held by the first process.
RESOURCE ALLOCATION GRAPH
 Deadlock can be describded more precisely in terms
of directed graph called a system resource
allocation graph.
 This graph consists of a set of vertices V and a set of
edges E.
 The set of vertices V is partitioned in two different
types of nodes:
1.P={P1,P2,P3…..,Pn},the set consisting of all the
active processes in the system.
2.R={R1,R2,R3….,Rm},the set consisting of all
resource types in the system.

Recovery from Deadlock in Operating

System
When a Deadlock Detection Algorithm determines that a
deadlock has occurred in the system, the system must
recover from that deadlock. There are two approaches of
breaking a Deadlock:
1. Process Termination:
To eliminate the deadlock, we can simply kill one or more
processes. For this, we use two methods:
  (a). Abort all the Deadlocked Processes:
Aborting all the processes will certainly break the
deadlock, but with a great expenses. The deadlocked
processes may have computed for a long time and the
result of those partial computations must be discarded
and there is a probability to recalculate them later.
 (b). Abort one process at a time untill deadlock
cycle is eliminated:
Abort one deadlocked process at a time, untill
deadlock cycle is eliminated from the system. Due to
this method, there may be considerable overhead,
because after aborting each process, we have to run
deadlock detection algorithm to check whether any
processes are still deadlocked.

2. Resource Preemption:
To eliminate deadlocks using resource preemption, we
preepmt some resources from processes and give those
resources to other processes. This method will raise three
issues –
 (a). Selecting a victim:
We must determine which resources and which
processes are to be preempted and also the order to
minimize the cost.
 (b). Rollback:
We must determine what should be done with the
process from which resources are preempted. One
simple idea is total rollback. That means abort the
process and restart it.
  (c). Starvation:
In a system, it may happen that same process is
always picked as a victim. As a result, that process will
never complete its designated task. This situation is
called Starvation and must be avoided. One solution
is that a process must be picked as a victim only a
finite number of times.

METHODS FOR HANDLING DEADLOKS

1. Deadlock Ignorance

Deadlock Ignorance is the most widely used

approach among all the mechanism. This is
being used by many operating systems
mainly for end user uses. In this approach,
the Operating system assumes that deadlock
never occurs. It simply ignores deadlock. This
approach is best suitable for a single end user
system where User uses the system only for
browsing and all other normal stuff.
If deadlock is very rare, then let it happen and reboot
the system. This is the approach that both Windows
and UNIX take.
2. Deadlock prevention

Deadlock happens only when Mutual

Exclusion, hold and wait, No preemption and
circular wait holds simultaneously. If it is
possible to violate one of the four conditions
at any time then the deadlock can never
occur in the system.
a)Mutual Exclusion
one or more than one resources are non-
sharable(only one process can use at a time).
For e.g-Printer can’t be used simultaneously
by several processes.
b) Hold and Wait
Hold and wait condition lies when a process
waits for some other resources while holding another
resources at the same time.

Deadlock occurs because there can be more

than one process which are holding one
resource and waiting for other in the cyclic
order.
However, we have to find out some
mechanism by which a process either doesn't
hold any resource or doesn't wait. That
means, a process must be assigned all the
necessary resources before the execution
starts. A process must not wait for any
resource once the execution has been started.
Process is the set of instructions which are
executed by the CPU. Each of the instruction
may demand multiple resources at the
multiple times. The need cannot be fixed by
the OS.
The problem with the approach is:
1. Practically not possible.
2. Possibility of getting starved will be
increases due to the fact that some
process may hold a resource for a very
long time.
c) No Preemption
Deadlock arises due to the fact that a process
can't be stopped once it starts.
However, if we take the resource away from
the process which is causing deadlock then
we can prevent deadlock.
This is not a good approach at all since if we
take a resource away which is being used by
the process then all the work which it has
done till now can become inconsistent.
Consider a printer is being used by any
process. If we take the printer away from that
process and assign it to some other process
then all the data which has been printed can
become inconsistent and ineffective and also
the fact that the process can't start printing
again from where it has left which causes
performance inefficiency.
d) Circular Wait
To violate circular wait, we can assign a
priority number to each of the resource. A
process can't request for a lesser priority
resource. This ensures that not a single
process can request a resource which is being
utilized by some other process and no cycle
will be formed.
Deadlock Avoidance
Deadlock avoidance can be done with Banker’s
Algorithm.
Banker’s Algorithm
Bankers’s Algorithm is resource allocation and
deadlock avoidance algorithm which test all the
request made by processes for resources, it checks
for the safe state, if after granting request system
remains in the safe state it allows the request and if
there is no safe state it doesn’t allow the request
made by the process.
Inputs to Banker’s Algorithm:
1. Max need of resources by each process.
2. Currently allocated resources by each process.
3. Max free available resources in the system.
The request will only be granted under the below
condition:
1. If the request made by the process is less than
equal to max need to that process.
2. If the request made by the process is less than
equal to the freely available resource in the
system.
#DEADLOCK DETECTION
If a system does not employ either a
deadlock prevention or a deadlock
avoidance algorithm then a deadlock
situation may occur.in this environment
the system must provide:
 An algorithm that examines the state
of the system to determine whether
the deadlock has occurred.
 An algorithm to recover the deadlock.