The Dining Philosophers - Practice Coding Problems

The Dining Philosophers - Problem

Concurrency Medium

The classic Dining Philosophers Problem is a fundamental concurrency challenge that illustrates the complexities of resource sharing in multithreaded environments.

The Setup: Five philosophers sit around a circular table, each with a bowl of spaghetti. Between each pair of adjacent philosophers lies a single fork. To eat, a philosopher must acquire both the fork to their left and the fork to their right.

The Challenge: Design a thread-safe solution where philosophers can alternate between thinking and eating without causing deadlock or starvation. Each philosopher is represented by a separate thread, and multiple philosophers may want to eat simultaneously.

Your Task: Implement the wantsToEat() method that coordinates the philosopher's actions:

philosopher: ID of the philosopher (0-4) who wants to eat
pickLeftFork() and pickRightFork(): Functions to acquire forks
eat(): Function called when both forks are acquired
putLeftFork() and putRightFork(): Functions to release forks

Constraints: The solution must be deadlock-free and ensure no philosopher starves while maintaining thread safety for concurrent access.

Input & Output

Basic Execution Flow

$ Input: 5 philosophers (0,1,2,3,4) want to eat concurrently

› Output: All philosophers can eat without deadlock using proper synchronization

💡 Note: With correct fork ordering or semaphore control, philosophers can safely alternate between thinking and eating without getting stuck in deadlock

Deadlock Scenario (Naive Approach)

$ Input: All 5 philosophers simultaneously pick up left fork

› Output: System deadlocks - no philosopher can proceed

💡 Note: When all philosophers grab their left fork simultaneously, each waits for their right fork (which is the left fork of their neighbor), creating a circular wait condition

Asymmetric Solution Success

$ Input: Philosophers 1,3 pick right fork first; 0,2,4 pick left fork first

› Output: At least one philosopher can always complete eating

💡 Note: Breaking the symmetry ensures that there's always a path for progress, preventing circular dependency and deadlock

Visualization

Tap to expand

Understanding the Visualization

The Setup

5 philosophers sit in a circle, each needs 2 forks to eat, but only 5 forks total exist

The Problem

If everyone grabs their left fork simultaneously, everyone waits for right fork = deadlock

The Solution

Break symmetry: some pick left-then-right, others pick right-then-left

Key Takeaway

🎯 Key Insight: By breaking symmetry in resource acquisition order, we eliminate the circular wait condition that causes deadlock while maintaining maximum concurrency

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time operations for mutex acquisition

✓ Linear Growth

Space Complexity

O(1)

Only requires mutexes for forks, no additional space

✓ Linear Space

Constraints

Exactly 5 philosophers numbered 0 to 4
Each philosopher must acquire both adjacent forks to eat
Solution must be deadlock-free and starvation-free
Multiple threads may call wantsToEat() concurrently
Fork operations are atomic and thread-safe

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses asymmetric fork ordering to break circular dependencies. Even-numbered philosophers (0,2,4) pick their left fork first, while odd-numbered philosophers (1,3) pick their right fork first. This simple asymmetry prevents deadlock while allowing maximum concurrency, making it the most elegant and efficient solution to the classic dining philosophers problem.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Synchronization (Deadlock Prone)	O(1)	O(1)	Simple mutex per fork without deadlock prevention
Semaphore Solution (Waiter Pattern)	O(1)	O(1)	Use a semaphore to limit concurrent philosophers, preventing deadlock
Asymmetric Fork Ordering (Optimal)	O(1)	O(1)	Break symmetry by ordering fork acquisition differently for odd/even philosophers

Naive Synchronization (Deadlock Prone) — Algorithm Steps

Create a mutex for each of the 5 forks
When philosopher wants to eat, lock left fork first
Then lock right fork
Call eat() function
Release both forks in any order

Visualization

Tap to expand

Step-by-Step Walkthrough

All philosophers pick left fork

Each philosopher successfully acquires their left fork

All try to pick right fork

Each philosopher waits for their right fork, which is held by their neighbor

Circular deadlock occurs

No philosopher can proceed, system is stuck

Code -

solution.c — C

#include <pthread.h>

typedef struct {
    pthread_mutex_t forks[5];
} DiningPhilosophers;

DiningPhilosophers* createDiningPhilosophers() {
    DiningPhilosophers* dp = malloc(sizeof(DiningPhilosophers));
    for (int i = 0; i < 5; i++) {
        pthread_mutex_init(&dp->forks[i], NULL);
    }
    return dp;
}

void wantsToEat(DiningPhilosophers* obj,
               int philosopher,
               void (*pickLeftFork)(),
               void (*pickRightFork)(),
               void (*eat)(),
               void (*putLeftFork)(),
               void (*putRightFork)()) {
    
    int leftFork = philosopher;
    int rightFork = (philosopher + 1) % 5;
    
    // Acquire left fork first
    pthread_mutex_lock(&obj->forks[leftFork]);
    pickLeftFork();
    
    // Then acquire right fork
    pthread_mutex_lock(&obj->forks[rightFork]);
    pickRightFork();
    
    // Eat
    eat();
    
    // Release forks
    putLeftFork();
    pthread_mutex_unlock(&obj->forks[leftFork]);
    
    putRightFork();
    pthread_mutex_unlock(&obj->forks[rightFork]);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time operations for lock acquisition

✓ Linear Growth

Space Complexity

O(1)

Fixed number of mutexes regardless of input size

✓ Linear Space

Constraints

Exactly 5 philosophers numbered 0 to 4
Each philosopher must acquire both adjacent forks to eat
Solution must be deadlock-free and starvation-free
Multiple threads may call wantsToEat() concurrently
Fork operations are atomic and thread-safe

67.2K Views

Medium Frequency

~35 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Naive Synchronization (Deadlock Prone) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler