Question:

The Dining Philosopher problem can be solved by:

Show Hint

In the Dining Philosopher problem, semaphores are used to avoid deadlock and ensure mutual exclusion while sharing resources.

Updated On: Jan 17, 2026

Use of semaphores
Use of overlays
Mutual exclusion
Bounded waiting

Hide Solution

Verified By Collegedunia

The Correct Option is A

Solution and Explanation

Step 1: Definition of the Dining Philosopher Problem.
The Dining Philosopher problem is a synchronization problem that models the situation where multiple philosophers share a set of resources (e.g., forks), but need to avoid deadlock and ensure that they can eat in turn.

Step 2: Use of semaphores.
Semaphores are used in operating systems to manage synchronization. In the Dining Philosopher problem, semaphores can be used to ensure that only one philosopher can pick up a fork at a time, thus avoiding deadlock and ensuring mutual exclusion.

Step 3: Explanation of other options.
- (2) Use of overlays: Overlays refer to a technique in memory management and are not relevant to the solution of the Dining Philosopher problem.
- (3) Mutual exclusion: While mutual exclusion is required to avoid deadlock, semaphores specifically are used to enforce this in the context of the Dining Philosopher problem.
- (4) Bounded waiting: Bounded waiting ensures that no process waits indefinitely, but it is not the primary solution to the problem.

Step 4: Conclusion.
The correct answer is **(1) Use of semaphores**, which ensures that philosophers can safely pick up and put down forks without causing deadlock.

Was this answer helpful?

Top Questions on Synchronization

Consider the following multi-threaded code segment (in a mix of C and pseudo-code), invoked by two processes $P1$ and $P2$, and each of the processes spawns two threads $T1$ and $T2$:

int x = 0; // global 
Lock L1; // global 
main() { 
	create a thread to execute foo(); // Thread T1 
	create a thread to execute foo(); // Thread T2 
	wait for the two threads to finish execution; 
	print(x); } 
foo() { 
	int y = 0; 
	Acquire L1; 
	x = x + 1; 
	y = y + 1; 
	Release L1; 
	print(y); }

Which of the following statement(s) is/are correct?

View Solution

Consider the following pseudocode, where S is a semaphore initialized to 5 in line#2 and counter is a shared variable initialized to 0 in line #1. Assume that the increment operation in line#7 is not atomic.
1. int counter = 0; 2. Semaphore S = init(5); 3. void parop(void) 4. { 5. wait(S); 6. wait(S); 7. counter++; 8. signal(S); 9. signal(S); 10. }
If five threads execute the function parop concurrently, which of the following program behavior(s) is/are possible?
- GATE CS - 2021
- Operating System
- Synchronization
View Solution

View All

Questions Asked in CUET PG exam

View More Questions