Skip to content

Semaphores in Process Synchronization

Peterson’s Algorithm in Process Synchronization

Last Updated : 10 Jan, 2025

Peterson’s Algorithm is a classic solution to the critical section problem in process synchronization. It ensures mutual exclusion meaning only one process can access the critical section at a time and avoids race conditions. The algorithm uses two shared variables to manage the turn-taking mechanism between two processes ensuring that both processes follow a fair order of execution. It’s simple and effective for solving synchronization issues in two-process scenarios. In this article we will learn about Peterson’s Algorithm, its working, and practical examples to help understand its use in process synchronization.

What is Peterson’s Algorithm?

Peterson’s Algorithm is a well-known solution for ensuring mutual exclusion in process synchronization. It is designed to manage access to shared resources between two processes in a way that prevents conflicts or data corruption. The algorithm ensures that only one process can enter the critical section at any given time while the other process waits its turn. Peterson’s Algorithm uses two simple variables one to indicate whose turn it is to access the critical section and another to show if a process is ready to enter. This method is often used in scenarios where two processes need to share resources or data without interfering with each other. It is simple, easy to understand, and serves as a foundational concept in process synchronization.

Algorithm for Pi process

Algorithm for Pi process

do{
  flag[i] = true;
  turn = j;
  while (flag[j] && turn == j);
  //critical section

  flag[i] = false;

  //remainder section
}while(true);

do{
  flag[j] = true;
  turn = i;
  while (flag[i] && turn == i);
  //critical section

  flag[j] = false;

  //remainder section
}while(true);

Peterson’s Algorithm Explanation

Peterson’s Algorithm is a mutual exclusion solution used to ensure that two processes do not enter into the critical sections at the same time. The algorithm uses two main components: a turn variable and a flag array.

The turn variable is an integer that indicates whose turn it is to enter the critical section.
The flag array contains Boolean values for each process, indicating whether a process wants to enter the critical section.

Here’s how Peterson’s Algorithm works step-by-step:

Initial Setup: Initially, both processes set their respective flag values to false, meaning neither wants to enter the critical section. The turn variable is set to the ID of one of the processes (either 0 or 1), indicating that it’s that process’s turn to enter.

Intention to Enter: When a process wants to enter the critical section, it sets its flag value to true signaling its intent to enter.

Set the Turn: Then the process, which is having the next turn, sets the turn variable to its own ID. This will indicate that it is its turn to enter the critical section.

Waiting Loop: Both processes enter a loop where they check the flag of the other process and the turn variable:
- If the other process wants to enter (i.e., flag[1 - processID] == true), and
- It’s the other process’s turn (i.e., turn == 1 - processID), then the process waits, allowing the other process to enter the critical section.
This loop ensures that only one process can enter the critical section at a time, preventing a race condition.

Critical Section: Once a process successfully exits the loop, it enters the critical section, where it can safely access or modify the shared resource without interference from the other process.

Exiting the Critical Section: After finishing its work in the critical section, the process resets its flag to false. This signals that it no longer wants to enter the critical section, and the other process can now have its turn.

By alternating turns and using these checks, Peterson’s algorithm ensures mutual exclusion, meaning only one process can access the critical section at a time, and both processes get an equal opportunity to do so.

Example of Peterson’s Algorithm

Peterson’s solution is often used as a simple example of mutual exclusion in concurrent programming. Here are a few scenarios where it can be applied:

Accessing a shared printer: Peterson’s solution ensures that only one process can access the printer at a time when two processes are trying to print documents.
Reading and writing to a shared file: It can be used when two processes need to read from and write to the same file, preventing concurrent access issues.
Competing for a shared resource: When two processes are competing for a limited resource, such as a network connection or critical hardware, Peterson’s solution ensures mutual exclusion to avoid conflicts.

Peterson’s algorithm –

C++

#include <iostream> #include <thread> #include <vector>  const int N = 2; // Number of threads (producer and consumer)  std::vector<bool> flag(N, false); // Flags to indicate readiness int turn = 0; // Variable to indicate turn  void producer(int j) {     do {         flag[j] = true; // Producer j is ready to produce         turn = 1 - j;   // Allow consumer to consume         while (flag[1 - j] && turn == 1 - j) {             // Wait for consumer to finish             // Producer waits if consumer is ready and it's consumer's turn         }          // Critical Section: Producer produces an item and puts it into the buffer          flag[j] = false; // Producer is out of the critical section          // Remainder Section: Additional actions after critical section     } while (true); // Continue indefinitely }  void consumer(int i) {     do {         flag[i] = true; // Consumer i is ready to consume         turn = i;       // Allow producer to produce         while (flag[1 - i] && turn == i) {             // Wait for producer to finish             // Consumer waits if producer is ready and it's producer's turn         }          // Critical Section: Consumer consumes an item from the buffer          flag[i] = false; // Consumer is out of the critical section          // Remainder Section: Additional actions after critical section     } while (true); // Continue indefinitely }  int main() {     std::thread producerThread(producer, 0); // Create producer thread     std::thread consumerThread(consumer, 1); // Create consumer thread      producerThread.join(); // Wait for producer thread to finish     consumerThread.join(); // Wait for consumer thread to finish      return 0; }

C

// code for producer (j)  // producer j is ready // to produce an item flag[j] = true;  // but consumer (i) can consume an item turn = i;  // if consumer is ready to consume an item // and if its consumer's turn while (flag[i] == true && turn == i)      { /* then producer will wait*/ }      // otherwise producer will produce     // an item and put it into buffer (critical Section)      // Now, producer is out of critical section     flag[j] = false;     // end of code for producer      //--------------------------------------------------------     // code for consumer i      // consumer i is ready     // to consume an item     flag[i] = true;      // but producer (j) can produce an item     turn = j;      // if producer is ready to produce an item     // and if its producer's turn     while (flag[j] == true && turn == j)          { /* then consumer will wait */ }          // otherwise consumer will consume         // an item from buffer (critical Section)          // Now, consumer is out of critical section         flag[i] = false; // end of code for consumer

Java

import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  public class Main {     static final int N = 2; // Number of threads (producer and consumer)     static final Lock lock = new ReentrantLock();     static final Condition[] readyToProduce = {lock.newCondition(), lock.newCondition()};     static volatile int turn = 0; // Variable to indicate turn      static void producer(int j) {         do {             lock.lock();             try {                 while (turn != j) {                     readyToProduce[j].await();                 }                  // Critical Section: Producer produces an item and puts it into the buffer                 System.out.println("Producer " + j + " produces an item.");                  turn = 1 - j; // Allow consumer to consume                 readyToProduce[1 - j].signal();             } catch (InterruptedException e) {                 e.printStackTrace();             } finally {                 lock.unlock();             }              // Remainder Section: Additional actions after critical section         } while (true); // Continue indefinitely     }      static void consumer(int i) {         do {             lock.lock();             try {                 while (turn != i) {                     readyToProduce[i].await();                 }                  // Critical Section: Consumer consumes an item from the buffer                 System.out.println("Consumer " + i + " consumes an item.");                  turn = 1 - i; // Allow producer to produce                 readyToProduce[1 - i].signal();             } catch (InterruptedException e) {                 e.printStackTrace();             } finally {                 lock.unlock();             }              // Remainder Section: Additional actions after critical section         } while (true); // Continue indefinitely     }      public static void main(String[] args) {         Thread producerThread = new Thread(() -> producer(0)); // Create producer thread         Thread consumerThread = new Thread(() -> consumer(1)); // Create consumer thread          producerThread.start(); // Start producer thread         consumerThread.start(); // Start consumer thread          try {             Thread.sleep(1000); // Run for 1 second         } catch (InterruptedException e) {             e.printStackTrace();         } finally {             producerThread.interrupt(); // Interrupt producer thread             consumerThread.interrupt(); // Interrupt consumer thread         }     } }

Python

import threading  N = 2  # Number of threads (producer and consumer) flag = [False] * N  # Flags to indicate readiness turn = 0  # Variable to indicate turn  # Function for producer thread def producer(j):     while True:         flag[j] = True  # Producer j is ready to produce         turn = 1 - j  # Allow consumer to consume         while flag[1 - j] and turn == 1 - j:             # Wait for consumer to finish             # Producer waits if consumer is ready and it's consumer's turn             pass          # Critical Section: Producer produces an item and puts it into the buffer          flag[j] = False  # Producer is out of the critical section          # Remainder Section: Additional actions after critical section  # Function for consumer thread def consumer(i):     while True:         flag[i] = True  # Consumer i is ready to consume         turn = i  # Allow producer to produce         while flag[1 - i] and turn == i:             # Wait for producer to finish             # Consumer waits if producer is ready and it's producer's turn             pass          # Critical Section: Consumer consumes an item from the buffer          flag[i] = False  # Consumer is out of the critical section          # Remainder Section: Additional actions after critical section  # Create producer and consumer threads producer_thread = threading.Thread(target=producer, args=(0,)) consumer_thread = threading.Thread(target=consumer, args=(1,))  # Start the threads producer_thread.start() consumer_thread.start()  # Wait for the threads to finish producer_thread.join() consumer_thread.join()

C#

using System; using System.Threading; using System.Collections.Generic;  class GFG {     const int N = 2; // Number of threads     static List<bool> flag = new List<bool>(new bool[N]);     static int turn = 0; // Variable to indicate turn     // Producer method     static void Producer(object obj)     {         int j = (int)obj;         do         {             flag[j] = true;             turn = 1 - j;             // Wait for consumer to finish             // Producer waits if consumer is ready and it's consumer's turn             while (flag[1 - j] && turn == 1 - j)             {                 // Wait             }             // Critical Section: Producer produces an item and              // puts it into the buffer             Console.WriteLine($"Producer {j} produced an item");             flag[j] = false;             // Remainder Section: Additional actions after critical section             Thread.Sleep(1000);          } while (true);     }     // Consumer method     static void Consumer(object obj)     {         int i = (int)obj;         do         {             flag[i] = true;             turn = i;             // Wait for producer to finish             // Consumer waits if producer is ready and it's producer's turn             while (flag[1 - i] && turn == i)             {                 // Wait             }             // Critical Section: Consumer consumes an item from buffer             Console.WriteLine($"Consumer {i} consumed an item");             flag[i] = false;             // Remainder Section: Additional actions after critical section             Thread.Sleep(1000);         } while (true);     }     static void Main(string[] args)     {         Thread producerThread = new Thread(Producer); // Create producer thread         Thread consumerThread = new Thread(Consumer); // Create consumer thread         producerThread.Start(0); // Start producer thread with index 0         consumerThread.Start(1); // Start consumer thread with index 1         producerThread.Join(); // Wait for producer thread to finish         consumerThread.Join(); // Wait for consumer thread to finish     } }

JavaScript

const N = 2; // Number of threads (producer and consumer) const lockObject = {}; // Lock object for synchronization  async function producer(j) {     while (true) {         await new Promise((resolve) => {             lock(lockObject, () => {                 // Critical Section: Producer produces an item and puts it into the buffer                 console.log(`Producer ${j} produces an item`);                 // Remainder Section: Additional actions after the critical section             });             resolve();         });         await sleep(100); // Simulate some work before the next iteration     } }  async function consumer(i) {     while (true) {         await new Promise((resolve) => {             lock(lockObject, () => {                 // Critical Section: Consumer consumes an item from the buffer                 console.log(`Consumer ${i} consumes an item`);                 // Remainder Section: Additional actions after the critical section             });             resolve();         });         await sleep(100); // Simulate some work before the next iteration     } }  function sleep(ms) {     return new Promise(resolve => setTimeout(resolve, ms)); }  function lock(obj, callback) {     if (!obj.__lock__) {         obj.__lock__ = true;         try {             callback();         } finally {             delete obj.__lock__;         }     } }  // Start producer and consumer threads producer(0); // Start producer 0 producer(1); // Start producer 1 consumer(0); // Start consumer 0 consumer(1); // Start consumer 1  // Run for 1 second setTimeout(() => {     process.exit(); // Terminate the program after 1 second }, 1000);

Explanation of the above code:

This code shows a simple version of Peterson’s Algorithm for synchronizing two processes: a producer and a consumer. The goal is to make sure that both processes don’t interfere with each other while accessing a shared resource, which is a buffer in this case. The producer creates items, and the consumer takes them.

Here’s a detailed explanation of the code:

Producer (j)

Producer is ready to produce:
- flag[j] = true;: This indicates that the producer (process j) is ready to produce an item. The flag array holds the intentions of both processes (producer and consumer). When the producer sets its flag to true, it means it’s willing to access the shared resource (the buffer).

Set the turn for consumer:
- turn = i;: The turn variable is used to decide whose turn it is to enter the critical section (where the shared resource is accessed). Here, the producer is setting the turn to the consumer (process i), meaning the producer is willing to wait if the consumer wants to consume an item.

Wait until the consumer is done:
- while (flag[i] == true && turn == i) : This is the crucial part of the algorithm. The producer checks if the consumer has indicated that it is ready (flag[i] == true) and whether it’s the consumer’s turn (turn == i). If both conditions are true the producer must wait (it cannot enter the critical section). This ensures that the consumer gets a chance to consume before the producer produces a new item.

Producer produces an item:
- Once the condition in the while loop is no longer true (meaning either the consumer is not ready or it is the producer’s turn), the producer can safely enter the critical section, produce an item, and place it into the buffer.

Exit the critical section:
- flag[j] = false;: After the producer finishes its work in the critical section, it sets its flag to false, indicating that it is done and no longer wants to produce. This allows the consumer to have the opportunity to consume the item next.

Consumer (i)

Consumer is ready to consume:
- flag[i] = true;: The consumer sets its flag to true, indicating that it is ready to consume an item from the buffer.

Set the turn for producer:
- turn = j;: The consumer sets the turn variable to the producer’s process ID (j). This indicates that it is the producer’s turn to produce if the consumer is done consuming.

Wait until the producer is done:
- while (flag[j] == true && turn == j) : This is similar to the producer’s waiting condition. The consumer checks if the producer is ready to produce (flag[j] == true) and whether it’s the producer’s turn (turn == j). If both conditions are true, the consumer must wait, allowing the producer to produce an item.

Consumer consumes an item:
- Once the while loop exits (meaning the consumer is allowed to consume), the consumer enters the critical section and consumes an item from the buffer.

Exit the critical section:
- flag[i] = false;: After consuming the item, the consumer sets its flag to false, indicating it no longer wants to consume. This allows the producer to have the opportunity to produce the next item.

Read more about Peterson’s Solution for mutual exclusion | Set 1
Read more about Peterson’s Solution for mutual exclusion | Set 2

Advantages of the Peterson’s Solution

With Peterson’s solution, multiple processes can access and share a resource without causing any resource conflicts.
Every process has a chance to be carried out.
It uses straightforward logic and is easy to put into practice.
Since it is entirely software dependent and operates in user mode, it can be used with any hardware.
eliminates the chance of a deadlock.

Disadvantages of the Peterson’s Solution

Waiting for the other processes to exit the critical region may take a long time. We call it busy waiting.
On systems that have multiple CPUs, this algorithm might not function.

Conclusion

Peterson’s Algorithm is a simple and effective way to achieve mutual exclusion between two processes. It ensures that only one process accesses the critical section at a time, preventing conflicts and data inconsistency. While it works well for two processes, its limitations make it less practical for larger systems. Understanding and implementing Peterson’s Algorithm helps in learning the basics of process synchronization, which is crucial for managing shared resources in concurrent programming.

What is synchronization in concurrent programming?

Synchronization refers to the coordination of multiple processes or threads to achieve a desired outcome. It involves using synchronization mechanisms like locks, semaphores, or mutexes to control access to shared resources and prevent race conditions or conflicts.

What is Peterson’s solution in OS?

Peterson’s Solution is a mutual exclusion algorithm used in operating systems to ensure that two processes do not enter their critical sections simultaneously. It provides a simple and effective way to manage access to shared resources by two processes, preventing race conditions. The solution uses two shared variables to coordinate the two processes: a flag array and a turn variable.

What are the common synchronization mechanisms used in concurrent programming?

Common synchronization mechanisms include locks, semaphores, condition variables, monitors, and atomic operations. These mechanisms provide ways to control access to shared resources and coordinate the execution of concurrent processes or threads.

What is the difference between Peterson and Dekker algorithm?

Peterson’s Algorithm and Dekker’s Algorithm both solve the mutual exclusion problem, but Peterson’s is simpler and designed specifically for two processes, using shared variables to control the turn-taking mechanism. Dekker’s Algorithm, while also designed for two processes, is more complex due to its alternating turn logic and additional checks to prevent race conditions. Peterson’s Algorithm tends to be more efficient, while Dekker’s can be extended to more processes but involves more steps in synchronization.

Semaphores in Process Synchronization

GeeksforGeeks

Improve

Article Tags :

Practice Tags :

Algorithms

Similar Reads

Operating System Tutorial

An Operating System(OS) is a software that manages and handles hardware and software resources of a computing device. Responsible for managing and controlling all the activities and sharing of computer resources among different running applications.A low-level Software that includes all the basic fu