Codestin Search App

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

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

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

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
✓ Asymmetric Fork Ordering (Optimal)	O(1)	O(1)	Break symmetry by ordering fork acquisition differently for odd/even philosophers
Semaphore Solution (Waiter Pattern)	O(1)	O(1)	Use a semaphore to limit concurrent philosophers, preventing deadlock
Naive Synchronization (Deadlock Prone)	O(1)	O(1)	Simple mutex per fork without deadlock prevention

Asymmetric Fork Ordering (Optimal) — Algorithm Steps

Create mutex for each fork
For even philosophers (0,2,4): pick left fork first, then right
For odd philosophers (1,3): pick right fork first, then left
This breaks the circular chain and prevents deadlock
All philosophers can potentially eat simultaneously

Visualization

Tap to expand

Step-by-Step Walkthrough

Even philosophers: L→R

Philosophers 0,2,4 pick left fork first, then right fork

Odd philosophers: R→L

Philosophers 1,3 pick right fork first, then left fork

No circular wait

At least one philosopher can always acquire both forks

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;
    
    int firstFork, secondFork;
    void (*pickFirst)(), (*pickSecond)(), (*putFirst)(), (*putSecond)();
    
    // Break symmetry: odd philosophers pick right fork first
    if (philosopher % 2 == 1) {
        firstFork = rightFork; secondFork = leftFork;
        pickFirst = pickRightFork; pickSecond = pickLeftFork;
        putFirst = putRightFork; putSecond = putLeftFork;
    } else {
        firstFork = leftFork; secondFork = rightFork;
        pickFirst = pickLeftFork; pickSecond = pickRightFork;
        putFirst = putLeftFork; putSecond = putRightFork;
    }
    
    // Acquire forks in determined order
    pthread_mutex_lock(&obj->forks[firstFork]);
    pickFirst();
    
    pthread_mutex_lock(&obj->forks[secondFork]);
    pickSecond();
    
    // Eat
    eat();
    
    // Release forks
    putFirst();
    pthread_mutex_unlock(&obj->forks[firstFork]);
    
    putSecond();
    pthread_mutex_unlock(&obj->forks[secondFork]);
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Asymmetric Fork Ordering (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler