OS Based Solutions in Process Synchronization

Operating system-based solutions to the critical section problem use tools like semaphores, Sleep-Wakeup and monitors. These mechanisms help processes synchronize and ensure only one process accesses the critical section at a time. They are widely used in multitasking systems for efficient resource management.

Different OS based solutions for critical section problem are:

• Semaphores
• Monitors
• Sleep-Wakeup

1. Semaphores

A semaphore is a synchronization tool used in concurrent programming to control access to shared resources. It works like a counter that tracks how many processes can use a resource at a time.

• Wait (P) operation: If the semaphore value > 0, it is decremented and the process continues; if 0, the process is blocked.
• Signal (V) operation: Increments the semaphore value or wakes up a blocked process.

Semaphores help prevent race conditions and allow coordination among multiple processes or threads. They are often called counting semaphores since their initial value decides how many processes can access the resource simultaneously

Types of Semaphores:

There are two types of semahore

1. Counting Semaphore – Allows multiple processes to access a resource up to a specified limit.
2. Binary Semaphore (Mutex) – Works like a simple lock, allowing only one process at a time.

Working of Semaphore

A semaphore is a simple yet powerful synchronization tool used to manage access to shared resources in a system with multiple processes. It works by maintaining a counter that controls access to a specific resource, ensuring that no more than the allowed number of processes access the resource at the same time.

Now let us see how it does so. First, look at two operations that can be used to access and change the value of the semaphore variable.

A critical section is surrounded by both operations to implement process synchronization. The below image demonstrates the basic mechanism of how semaphores are used to control access to a critical section in a multi-process environment, ensuring that only one process can access the shared resource at a time.

Now, let us see how it implements mutual exclusion. Let there be two processes P1 and P2 and a semaphore s is initialized as 1. Now if suppose P1 enters in its critical section then the value of semaphore s becomes 0. Now if P2 wants to enter its critical section then it will wait until s > 0, this can only happen when P1 finishes its critical section and calls V operation on semaphore s.

This way mutual exclusion is achieved. Look at the below image for details which is a Binary semaphore.

Implementation of Binary Semaphores

The description above is for binary semaphore which can take only two values 0 and 1 and ensure mutual exclusion. There is one other type of semaphore called counting semaphore which can take values greater than one.

• A resource has 4 instances, so the semaphore is initialized as S = 4.
• A process requests the resource using P (wait) and releases it using V (signal).
• If S = 0, new processes must wait until a resource is released.
• Example: P1, P2, P3, and P4 take all 4 instances (S = 0). If P5 requests, it waits until one of them calls signal and frees a resource.

Implementation of Counting semaphore

In this implementation whenever the process waits it is added to a waiting queue of processes associated with that semaphore. This is done through the system call block() on that process. When a process is completed it calls the signal function and one process in the queue is resumed. It uses the wakeup() system call.

Read More about Semaphores

2. Monitors

Monitors are advanced tools provided by operating systems to control access to shared resources. They group shared variables, procedures, and synchronization methods into one unit making sure that only one process can use the monitor's procedures at a time.

Key Features of Monitors

• Automatic Mutual Exclusion: Only one process can access the monitor at a time, eliminating the need for manual locks.
• Condition Variables: Monitors use condition variables with operations like wait() and signal() to handle process synchronization:
• Built-In Synchronization: The operating system ensures that no two processes are inside the monitor simultaneously, simplifying the synchronization process.

Syntax

A condition variable has its own block queue.

• x.wait(): suspends the calling process and places it in x’s queue.
• x.signal(): wakes up one process from x’s queue (if any).

If (x block queue empty)
// Ignore signal
else
// Resume a process from block queue.

Read More about Monitors

3. Sleep-Wakeup

The Sleep and Wakeup mechanism is an operating system-based solution to the critical section problem. It helps processes to avoid busy waiting while waiting for access to shared resources.

How It Works

Sleep

• When a process wants to enter the critical section but finds the resource is already being used by another process, it doesn’t keep checking in a loop.
• Instead, it is put to sleep. This means the process temporarily stops running and frees up CPU resources, allowing other processes to execute.

Wakeup

• Once the resource becomes available (e.g., the current process in the critical section finishes its work), the operating system or another process sends a wakeup signal to the sleeping process.
• The sleeping process then resumes execution and checks if it can now enter the critical section.

Example

Imagine two processes, P1 and P2, want to use a printer (a shared resource):

• If P1 is already using the printer, P2 goes to sleep instead of repeatedly checking if the printer is free.
• When P1 finishes printing, it sends a wakeup signal to P2 letting it know the printer is now available.

Benefits

• Avoids Busy Waiting: Processes don’t waste CPU time checking for resource availability.
• Efficient Resource Usage: The CPU can focus on other processes while one waits.
• Simplifies Synchronization: Processes are paused and resumed automatically based on resource availability.