How are deadlocks handled?

PublishedMarch 9, 2024

I am Jyotiprakash, a deeply driven computer systems engineer, software developer, teacher, and philosopher. With a decade of professional experience, I have contributed to various cutting-edge software products in network security, mobile apps, and healthcare software at renowned companies like Oracle, Yahoo, and Epic. My academic journey has taken me to prestigious institutions such as the University of Wisconsin-Madison and BITS Pilani in India, where I consistently ranked among the top of my class.

At my core, I am a computer enthusiast with a profound interest in understanding the intricacies of computer programming. My skills are not limited to application programming in Java; I have also delved deeply into computer hardware, learning about various architectures, low-level assembly programming, Linux kernel implementation, and writing device drivers. The contributions of Linus Torvalds, Ken Thompson, and Dennis Ritchie—who revolutionized the computer industry—inspire me. I believe that real contributions to computer science are made by mastering all levels of abstraction and understanding systems inside out.

In addition to my professional pursuits, I am passionate about teaching and sharing knowledge. I have spent two years as a teaching assistant at UW Madison, where I taught complex concepts in operating systems, computer graphics, and data structures to both graduate and undergraduate students. Currently, I am an assistant professor at KIIT, Bhubaneswar, where I continue to teach computer science to undergraduate and graduate students. I am also working on writing a few free books on systems programming, as I believe in freely sharing knowledge to empower others.

Comments

Join the discussion

No comments yet. Be the first to comment.

More from this blog

Computer Arithmetic: From Fast Adders to Floating-Point

Arithmetic is the beating heart of every processor. Whether your machine is rendering 3-D graphics, training a neural network, or simply incrementing a loop counter, the ALU (Arithmetic Logic Unit) is doing the heavy lifting. In this deep-dive, I wan...

Feb 12, 202629 min read

The Complete Memory Hierarchy: From Semiconductor RAM to Virtual Memory

The performance gap between processors and main memory has been widening for decades. Modern processors can execute billions of instructions per second, but accessing data from main memory takes hundreds of processor cycles. This disparity creates a ...

Jan 7, 202670 min read

The Ultimate Spring Boot Guide: From Fundamentals to Production-Ready REST APIs

Introduction Welcome to the most comprehensive Spring Boot guide you'll find! This isn't just another tutorial that skims the surface. We're going to dive deep into every concept, explain every annotation, walk through every line of code, and underst...

Dec 26, 2025125 min read

Understanding Functions, Memory, and Pointers in C: A Complete Guide

Part 1: Functions and the Call Stack Before we can understand pointers and memory management in C, we need to understand how functions work and what happens behind the scenes when your program runs. This foundation will make everything else click int...

Dec 16, 202583 min read

Datapath and Control

The Basic Processing Unit is the brain of every computer. It fetches instructions from memory, decodes them, and executes the operations they specify. Whether you're running a simple addition or a complex algorithm, every operation flows through this...

Dec 10, 202534 min read

Jyotiprakash's Blog

251 posts

I'm Jyotiprakash, a software dev and professor at KIIT, with expertise in system programming.

Dealing with deadlocks in computer systems can be approached in three main ways:

Prevention or Avoidance: This approach involves implementing protocols to ensure that deadlocks do not occur. By preventing or avoiding deadlocks, the system is kept in a state where deadlock conditions are never met. Prevention strategies focus on negating one or more of the necessary conditions for a deadlock, such as mutual exclusion, hold and wait, no preemption, and circular wait, by imposing constraints on how resources are requested. Avoidance techniques, on the other hand, require the system to have prior knowledge of the resources each process will request and use throughout its lifetime. With this information, the system can make informed decisions on whether to grant or delay resource requests to avoid deadlocks.
Detection and Recovery: In scenarios where prevention or avoidance is not implemented, systems can still manage deadlocks by detecting when they occur and then recovering from them. This method involves monitoring the system's state to identify deadlocks and then taking action to resolve them, such as terminating processes or forcefully taking resources away from them. This approach accepts that deadlocks may occur but deals with them as they arise.
Ignoring the Problem: Surprisingly, many operating systems, including Linux and Windows, choose to ignore the deadlock problem. This doesn't mean they are unaware of deadlocks but rather that they accept the risk of their occurrence as part of the system's operation. It becomes the responsibility of application developers to manage deadlocks within their programs. This approach is chosen primarily because deadlocks are relatively rare and the cost of implementing comprehensive deadlock management strategies may not justify the benefits for every system.

Each of these methods has its pros and cons, and some researchers argue that no single approach is universally best for all types of resource-allocation problems. Systems can, therefore, adopt a combination of strategies tailored to different resource types and application needs.

Prevention and Avoidance: Detailed algorithms for these strategies are explored in specific sections of the discussion (in further blogs), highlighting methods to ensure that systems either do not reach deadlock conditions or smartly navigate resource requests to avoid potential deadlocks.
Detection and Recovery: When neither prevention nor avoidance is in place, systems need mechanisms to detect deadlocks and strategies to recover from them. Without these mechanisms, undetected deadlocks can severely degrade system performance and eventually necessitate manual intervention.

Ignoring deadlocks is a pragmatic choice for some systems, prioritizing cost savings and simplicity over the complexity of managing deadlocks. This approach relies on the infrequency of deadlocks and the existence of general recovery methods for system issues, which can also be applied to resolve deadlock situations when they are identified manually.

Command Palette

Comments

More from this blog