Dining Philosophers Problem and Solution in Java

The Dining Philosophers Problem is an example of a concurrency problem dealing with the allocation of limited resources among competing processes. In this section, we will understand how to avoid deadlock conditions in dining philosophers problem. It is the undesirable condition of concurrent systems. It is marked as in a circular waiting state. First, we will discuss the Dining Philosophers Problem that is used in the operating systems after that we will move towards the solution. Also, we will implement the solution in a Java program.

Dining Philosophers Problem

The pictorial representation of the problem is as follows.

The above figure represents that there are five philosophers (labeled with P1, P2, P3, P4, and P5) sitting around a circular dining table. There are five plates of noodles to eat when philosophers feel hungry. To eat noodles, there are five forks/ chopsticks (labeled with 1 to 5) placed between each philosopher.

Each philosopher eats and thinks alternatively. There are the following conditions followed by each philosopher:

A philosopher will use both forks/ chopsticks (right and left) to eat.
Remaining one fork may be picked up by any one of its adjacent philosophers but not both.
A philosopher may have noodles if both forks are available.
After eating, a philosopher will put down both forks and starts thinking again.
Those forks can be picked by the other philosophers who will repeat the same process.
No two neighbor philosophers (right and left) can eat together.

process P[i]
while (true) 
do
{  
think();	//initially all philosophers are thinking
pickupFork(fork[i], fork[i+1 mod 5]);
eat();	//start eating
putdownFork(fork[i], fork[i+1 mod 5]) //after eating puts down both the forks
}

Initially, all philosophers are thinking. After some time, gets hungry and wants to eat noodles. The philosopher looks for the forks on either side. When the philosopher gets both the forks, he starts eating. After eating, he puts down the forks and starts thinking again. When the philosopher puts down the forks, those forks may be used by neighbor philosophers.

In such a case, there is the possibility of deadlock, a condition in which two or more processes cannot continue execution. The problem is used to design a scheduling technique in such a way no philosopher will starve.

The Solution to the Dining Philosophers Problem

The solution to the dining philosophers' problem is to use Semaphore. It is a tool that is used for concurrent processes. There is a drawback of using Semaphore as a solution. It may lead to deadlock. Suppose a scenario when all philosophers pick up the left fork and wait for the right fork. The situation leads to a deadlock.

To avoid the deadlock solution, there are some measures that should have been taken are:

There should be at most four philosophers around the table.
A philosopher should allow picking forks when both forks are available at the same time.
The philosophers can alternatively eat and think. For example, if the first philosopher is eating then the adjacent neighbor philosophers should wait and think, and so on.

Implementation of Dining Philosophers Problem

In the following program, first, we have initialized the number of philosophers (5). The two arrays philosophers[] and chopsticks[] initialized with the number of philosophers (5).

In order to implement the logic for chopsticks, we have created a class named Chopstick. Inside the class, we have created a constructor of the Semaphore class and defined three methods namely grab(), release(), and isFree().

The grab() method invokes the acquire() method that acquires a permit from this semaphore. It reduces the number of permits by 1. If there is no permit is available the current thread becomes disabled.

The user-defined release() method invokes the release() method of the Semaphore class. It releases the given number of permits and increments the permit by 1.

The isFree() method checks for the availability of permits in the semaphore. It invokes the availablePermits() method of the Semaphore class that returns the number of permits available in the Semaphore.

After that, we have created another class named Philosopher that extends the Thread class. Inside the class, we have defined three variables number, leftchopstick, and rightchopstick. Also, we have created a constructor of the Philosopher class and the eat() method. The run() method of the Thread class is called if the thread was constructed using a separate Runnable object.

The run() method executes when a philosopher has both chopsticks (right and left). A philosopher starts eating by invoking the eat() method and holds the fork for a specified time (sleep time). In order to determine the sleep time, we have used the ThreadLocalRandom. current(). nextInt() method. The method returns a pseudorandom, uniformly distributed integer value between 0 and 1000. The value is determined by the nextInt() method passed in the sleep() method that sleeps the thread for a specified time. In our case, if sleep time is more than 1000ms, the program will exit. So, we can set the range of pseudorandom numbers (sleep time).

Inside the main() method, we have defined the two for loops one for chopsticks, and the other for philosophers. After that, we have checked for deadlock conditions. If a deadlock occurs, it means each philosopher is eating by acquiring the chopsticks. The execution of the program breaks. The deadlock condition will not occur until resources (a single chopstick) is available.

DiningPhilosophersProblem.java

import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadLocalRandom;
public class DiningPhilosophersProblem
{
//defining the number of philosophers
static int philosopher = 5;
//initializing an array of philosophers with the number of philosophers
static Philosopher philosophers[] = new Philosopher[philosopher];
//initializing an array of chosticks with the number of philosophers
static Chopstick chopsticks[] = new Chopstick[philosopher];
static class Chopstick 
{
//creating a constructor of the Semaphore class that accepts the number permits
public Semaphore mutex = new Semaphore(1);
//the method grabs the chopstick
void grab() 
{
try 
{
//acquires a permit from the semaphore
mutex.acquire();
}
catch (Exception e) 
{
e.printStackTrace(System.out);
}
}
//release the chopstick
void release() 
{
//releases an acquire a permit and increases the number of available permits by one
mutex.release();
}
//checks if the chopstick is free or not
boolean isFree() 
{
//the method returns the current number of permits available in the semaphore
//returns true if available permits is greater than 0, else returns false
return mutex.availablePermits() > 0;
}
}  //end of Chopstick class
static class Philosopher extends Thread 
{
public int number;
//represents left chopstick
public Chopstick leftchopstick;
//represents right chopstick
public Chopstick rightchopstick;
//creating a constructor of the Philosopher class
Philosopher(int num, Chopstick left, Chopstick right) 
{
number = num;
leftchopstick = left;
rightchopstick = right;
}
public void run()
{
while (true) 
{
//philosopher grabs the chopsticks if both are free
leftchopstick.grab();
System.out.println("Philosopher " + (number+1) + " grabs left chopstick.");
rightchopstick.grab();
System.out.println("Philosopher " + (number+1) + " grabs right chopstick.");
//hunger philosopher starts eating 
eat();
//releases left and right chopsticks when philosopher is not hunger
leftchopstick.release();
System.out.println("Philosopher " + (number+1) + " releases left chopstick.");
rightchopstick.release();
System.out.println("Philosopher " + (number+1) + " releases right chopstick.");
}  //end of while loop
} //end of run() method
//the method invokes after grabbing both the chopsticks (left and right)
void eat() 
{
try 
{
//determines the pseudorandom number between 0 to 1000 that represents the sleep time in milli seconds
int sleepTime = ThreadLocalRandom.current().nextInt(0, 1000);
System.out.println("Philosopher " + (number+1) + " eats for " + sleepTime +"ms"); //sleeps the thread for a specified time
Thread.sleep(sleepTime);
}
catch (Exception e) 
{
e.printStackTrace(System.out);
}
}// end of eat() method
}
public static void main(String args[]) 
{
//loop iterates over chopsticks
for (int i = 0; i < philosopher; i++) 
{
chopsticks[i] = new Chopstick();
} //end of for loop
//loop iterates over philosopher
for (int i = 0; i < philosopher; i++) 
{
philosophers[i] = new Philosopher(i, chopsticks[i], chopsticks[(i + 1) % philosopher]);
//begins the execution of the thread
philosophers[i].start();
} //end of for loop
while (true) 
{
try 
{
//thread sleep for 1 sec or 1000ms
Thread.sleep(1000);
//check for deadlock condition
boolean deadlock = true;
//for each loop iterates over chopsticks
for (Chopstick cs : chopsticks) 
{
//checks if chopstick is free or not 
if (cs.isFree()) 
{
deadlock = false;
break;
} //end of if
} //end of for loop
//deadlock occurs if sleep time is 1000ms it means each philosopher is eating
if (deadlock) 
{
Thread.sleep(1000);
System.out.println("Everyone Eats");
break;
} //end of if
}
catch (Exception e) 
{
e.printStackTrace(System.out);
}
}
System.out.println("Exit The Program!");
System.exit(0);
}
} 

Output: