Operating System - Dining Philosophers Problem

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <random>

using namespace std::chrono_literals;

class Semaphore {
public:
    explicit Semaphore(int initial) : count(initial) {}
    // try to acquire within timeout; returns true if acquired
    bool try_acquire_for(std::chrono::milliseconds timeout) {
        std::unique_lock<std::mutex> lk(m);
        if (!cv.wait_for(lk, timeout, [&]{ return count > 0; })) return false;
        --count;
        return true;
    }
    void release() {
        std::lock_guard<std::mutex> lk(m);
        ++count;
        cv.notify_one();
    }
private:
    std::mutex m;
    std::condition_variable cv;
    int count;
};

int main() {
    const int N = 6;
    std::vector<std::timed_mutex> forks(N);
    Semaphore waiter(N - 1);
    std::atomic<bool> stop_flag{false};

    auto philosopher = [&](int i) {
        // per-thread RNG
        std::mt19937 rng(std::random_device{}() ^ (i << 8));
        std::uniform_int_distribution<int> think_ms(200, 600);
        std::uniform_int_distribution<int> eat_ms(200, 600);

        while (!stop_flag.load(std::memory_order_relaxed)) {
            std::cout << "Philosopher " << i << " is thinking." << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(think_ms(rng)));

            // request permission from the waiter (timeout so we can exit)
            if (!waiter.try_acquire_for(500ms)) continue;

            bool left_locked = false, right_locked = false;
            // try acquire left fork
            left_locked = forks[i].try_lock_for(500ms);
            if (!left_locked) {
                waiter.release();
                continue;
            }
            // try acquire right fork
            right_locked = forks[(i + 1) % N].try_lock_for(500ms);
            if (!right_locked) {
                forks[i].unlock();
                waiter.release();
                continue;
            }

            // Both forks acquired
            try {
                std::cout << "Philosopher " << i << " is eating." << std::endl;
                std::this_thread::sleep_for(std::chrono::milliseconds(eat_ms(rng)));
            } catch (...) {
                // not expected, but ensure release
            }

            // release forks and waiter
            forks[(i + 1) % N].unlock();
            forks[i].unlock();
            waiter.release();
        }
        // exiting
        //std::cout << "Philosopher " << i << " exiting.\n";
    };

    std::vector<std::thread> threads;
    threads.reserve(N);
    for (int i = 0; i < N; ++i) threads.emplace_back(philosopher, i);

    // run for 5 seconds
    std::this_thread::sleep_for(5s);
    stop_flag.store(true);

    for (auto &t : threads) if (t.joinable()) t.join();

    std::cout << "Simulation finished.\n";
    return 0;
}

The output of the above code will be similar to below −

Philosopher 0 is thinking.
Philosopher 1 is thinking.
Philosopher 2 is thinking.
Philosopher 3 is thinking.
Philosopher 4 is thinking.
Philosopher 5 is thinking.
Philosopher 3 is eating.
Philosopher 1 is eating.
Philosopher 3 is thinking.
.......
Simulation finished.

import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock; 
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.Random;

public class Dining {
    static final int N = 6;

    public static void main(String[] args) throws InterruptedException {
        final ReentrantLock[] forks = new ReentrantLock[N];
        for (int i = 0; i < N; ++i) forks[i] = new ReentrantLock();

        final Semaphore waiter = new Semaphore(N - 1);
        final AtomicBoolean stop = new AtomicBoolean(false);

        Thread[] threads = new Thread[N];

        for (int i = 0; i < N; ++i) {
            final int id = i;

            threads[i] = new Thread(() -> {
                Random rng = new Random(System.nanoTime() ^ (id << 8));

                while (!stop.get()) {
                    System.out.println("Philosopher " + id + " is thinking.");
                    try {
                        Thread.sleep(200 + rng.nextInt(401)); // 200–600 ms
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        break;
                    }

                    boolean gotWaiter = false;
                    boolean leftLocked = false;
                    boolean rightLocked = false;

                    try {
                        gotWaiter = waiter.tryAcquire(500, TimeUnit.MILLISECONDS);
                        if (!gotWaiter) continue;

                        leftLocked = forks[id].tryLock(500, TimeUnit.MILLISECONDS);
                        if (!leftLocked) continue;

                        rightLocked = forks[(id + 1) % N].tryLock(500, TimeUnit.MILLISECONDS);
                        if (!rightLocked) continue;

                        System.out.println("Philosopher " + id + " is eating.");
                        Thread.sleep(200 + rng.nextInt(401));

                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        break;

                    } finally {
                        if (rightLocked) forks[(id + 1) % N].unlock();
                        if (leftLocked) forks[id].unlock();
                        if (gotWaiter) waiter.release();
                    }
                }
            });

            threads[i].start();
        }

        Thread.sleep(5000);
        stop.set(true);

        for (Thread t : threads) t.join();

        System.out.println("Simulation finished.");
    }
}

The output of the above code will be similar to below −

Philosopher 0 is thinking.
Philosopher 1 is thinking.
Philosopher 2 is thinking.
Philosopher 3 is thinking.
Philosopher 4 is thinking.
Philosopher 5 is thinking.
Philosopher 4 is eating.
Philosopher 2 is eating.
Philosopher 4 is thinking.
.......
Simulation finished.