Deadlock in OS (Operating System) – Examples & Methods of Handling

Process Deadlock is a classical issue in operating systems, especially where there is process scheduling and concurrent user access to resources. It happens when several processes are stuck, with each process anxiously waiting for the release of a resource that only the process holding it can release. This deadlock can seriously impact the performance and reliability of the system, and hence, suitable strategies for detecting, preventing and handling the situation are needed. It occurs when a set of processes becomes permanently blocked because each process waits for a resource that another process holds, creating a cycle of dependency that no process can break on its own. The deadlock can severely affect the system’s performance and stability, requiring efficient detection, avoidance, and recovery strategies.

What is Deadlock in OS?

Deadlocks occur in an operating system when two or more processes cannot proceed because each is waiting for the other to release a resource. This condition creates a cycle of dependency, leading to a halt in the execution for the involved processes.

In the above figure, there are two processes and two resources. Process 1 holds “Resource 1” and needs “Resource 2” while Process 2 holds “Resource 2” and requires  “Resource 1”. This creates a deadlock situation because none of the two processes can be executed. Since the resources are non-shareable they can only be used by one process at  a time (Mutual Exclusion). Each process holds a resource and waits for the other process to release the resource it requires. None of the two processes release their resource before their execution, creating a circular wait when the four conditions are satisfied.

Necessary Conditions for Deadlock

There are four necessary conditions for a deadlock to arise, which are as follows.

• Mutual Exclusion: The only process that can use a resource at any given time is when the resource is non-shareable.

• Hold and Wait: A process holding at least one resource is waiting to acquire additional resources currently being held by another process. The processes will not release the existing resources while waiting for other resources, leading to a potential deadlock. For example, If a process has locked a file and is waiting for access to a pointer, while another process holds the printer and waits for the file, both processes could be stuck.

• No Preemption: No preemption means a resource cannot be forcibly removed from a process. It must be released voluntarily by the process holding it. If a process holds a resource and another requires it, the second process must wait until the first one releases it.

• Circular Wait: The end product is the circular wait condition in which the processes create a ring, and each process waits for the other to release a resource that the latter holds. For example, Process A is waiting to use a resource from Process B, Process B is waiting for a resource from Process C, and Process C is waiting for a resource from Process A.

Also Read: Deadlock Avoidance in OS

Methods of Handling Deadlocks in Operating Systems

The operating system deadlocks are events whereby several processes are halted as they each wait for some resource that the other process owns. Dealing with deadlocks is important justifiably because of its effectiveness in managing system freezes functional and system crashes, among others. Deadlocks can be prevented, avoided, or detected and recovered The methods of preventing them range from the technical to the practical. It is now the right time to discuss the principal approaches to solving deadlocks in operating systems.

• Deadlock Prevention: In this case, the aim is to prevent one of the required conditions from being fulfilled. This method can do this.

• Mutual Exclusion: We only use the lock for non-shareable resources, and if the resource is shareable, we do not use locks here. It ensures that multiple processes can access shareable resources at the same time. The problem is that we can only do it for shareable resources, but in the case of non-shareable resources like printers, we have to use Mutual exclusion.

• Hold and Wait: In this case, we ensure that hold and wait never occurs in the computer system, we must guarantee that whenever a process requests a resource it does not hold any other resources.

• No Preemption: The process is holding some resources and requisitioning other resources that are acquired and these resources are not available immediately then the resources that the current process is holding are preempted.

• Circular Wait: To remove the circular wait in the system, we can order the resources that a process needs to acquire.

• Deadlock Avoidance: . Deadlock avoidance is an active technique used in the operating system in order to prevent the system from getting into unsafe conditions in which deadlocks are bound to happen. While deadlock prevention attempts to remove one of the conditions that are prerequisite for deadlock, deadlock avoidance directs decisions on resource allocation in such a manner that the system never enters a deadlock state.

Difference between Starvation and Deadlocks

Also Read: Classification of Operating System

Conclusion

Deadlock is a critical issue in operating systems where a set of processes become stuck, each waiting for resources held by other processes, resulting in none of them progressing. It occurs due to four necessary conditions, mutual exclusion, hold and wait, no preemption, and circular wait. The challenge of handling deadlocks lies in preventing or resolving them without compromising system performance.