哲学家进餐问题

由荷兰学者Dijkstra提出的哲学家进餐问题(The Dinning Philosophers Problem)是经典的同步问题之一

有五个哲学家，他们的生活方式是交替地进行思考和进餐，哲学家们共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五支筷子，平时哲学家进行思考，饥饿时便试图取其左、右最靠近他的筷子，只有在他拿到两支筷子时才能进餐，该哲学家进餐完毕后，放下左右两只筷子又继续思考。
约束条件
(1)只有拿到两只筷子时，哲学家才能吃饭。
(2)如果筷子已被别人拿走，则必须等别人吃完之后才能拿到筷子。
(3)任一哲学家在自己未拿到两只筷子吃完饭前，不会放下手中已经拿到的筷子。

接下来用的至少需要C++11

死锁

整体思路就是拿左边上锁，拿右边上锁

但是有可能5个哲学家同时拿，这就导致他们拿完了左边，每个人都无法拿右边，就g了
尤其是拿完了左边，开始sleep，sleep越久就越有可能死锁

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>int getThinkTime(){return 1;
}int getEatTime(){return 1;
}void think(size_t id){std::cout<< id<< " starts thinking."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getThinkTime()));std::cout<< id<< " all done thinking."<< std::endl;
}void eat(size_t id, std::mutex& left, std::mutex& right){left.lock();std::this_thread::sleep_for(std::chrono::seconds(2));right.lock();std::cout<< id<< " starts eating om nom nom nom."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getEatTime()));std::cout<< id<< " all done eating."<< std::endl;left.unlock();right.unlock();
}void philosopher(size_t id, std::mutex& left, std::mutex& right){for(size_t i = 0; i < 3; ++i){think(id);eat(id, left, right);}
}int main(){std::mutex forks[5];std::thread philosophers[5];for(size_t i = 0; i < 5; ++i){philosophers[i] = std::thread(philosopher, i, ref(forks[i]), ref(forks[(i + 1) % 5]));}for(auto& p:philosophers)p.join();return 0;
}

奇偶

奇数先拿左边，偶数先拿右边

那么奇数人就是拿0, 2
偶数人拿1, 3, 0
这样0是不能同时拿，就不会死锁了

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>int getThinkTime(){return 1;
}int getEatTime(){return 1;
}void think(size_t id){std::cout<< id<< " starts thinking."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getThinkTime()));std::cout<< id<< " all done thinking."<< std::endl;
}void eat(size_t id, std::mutex& left, std::mutex& right){if(id & 1){left.lock();std::this_thread::sleep_for(std::chrono::seconds(2));right.lock();}else{right.lock();std::this_thread::sleep_for(std::chrono::seconds(2));left.lock();}std::cout<< id<< " starts eating om nom nom nom."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getEatTime()));std::cout<< id<< " all done eating."<< std::endl;left.unlock();right.unlock();
}void philosopher(size_t id, std::mutex& left, std::mutex& right){for(size_t i = 0; i < 3; ++i){think(id);eat(id, left, right);}
}int main(){std::mutex forks[5];std::thread philosophers[5];for(size_t i = 0; i < 5; ++i){philosophers[i] = std::thread(philosopher, i, ref(forks[i]), ref(forks[(i + 1) % 5]));}for(auto& p:philosophers)p.join();return 0;
}

条件变量

简单来说就是最多同时有4个哲学家操作，其实1-4都是可以的，只要不要让5个哲学家一起操作就行

我这里用的condition_variable_any，不仅可以操作lock_guard，还可以操作unique_lock
如果用condition_variable，那就只能操作unique_lock

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>int getThinkTime(){return 1;
}int getEatTime(){return 1;
}void think(size_t id){std::cout<< id<< " starts thinking."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getThinkTime()));std::cout<< id<< " all done thinking."<< std::endl;
}void waitForPermission(size_t& permits, std::condition_variable_any& cv, std::mutex& m){std::lock_guard<std::mutex> lg(m);cv.wait(m, [&permits](){return permits > 0;});--permits;
}void grantPermission(size_t& permits, std::condition_variable_any& cv, std::mutex& m){std::lock_guard<std::mutex> lg(m);++permits;if(permits == 1)cv.notify_all();
}void eat(size_t id, std::mutex& left, std::mutex& right, size_t& permits, std::condition_variable_any& cv, std::mutex& m){waitForPermission(permits, cv, m);left.lock();std::this_thread::sleep_for(std::chrono::seconds(2));right.lock();std::cout<< id<< " starts eating om nom nom nom."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getEatTime()));std::cout<< id<< " all done eating."<< std::endl;grantPermission(permits, cv, m);left.unlock();right.unlock();
}void philosopher(size_t id, std::mutex& left, std::mutex& right, size_t& permits, std::condition_variable_any& cv, std::mutex& m){for(size_t i = 0; i < 3; ++i){think(id);eat(id, left, right, permits, cv, m);}
}int main(){size_t permits = 4;std::condition_variable_any cv;std::mutex forks[5], m;std::thread philosophers[5];for(size_t i = 0; i < 5; ++i){philosophers[i] = std::thread(philosopher, i, std::ref(forks[i]), std::ref(forks[(i + 1) % 5]), std::ref(permits), std::ref(cv), std::ref(m));}for(auto& p:philosophers)p.join();return 0;
}

信号量

这个需要C++20，思路和上面差不多

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <semaphore>const int N = 5;int getThinkTime(){return 1;
}int getEatTime(){return 1;
}void think(size_t id){std::cout<< id<< " starts thinking."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getThinkTime()));std::cout<< id<< " all done thinking."<< std::endl;
}void eat(size_t id, std::mutex& left, std::mutex& right, std::counting_semaphore<N - 1>& permits){permits.acquire();left.lock();std::this_thread::sleep_for(std::chrono::seconds(2));right.lock();std::cout<< id<< " starts eating om nom nom nom."<< std::endl;std::this_thread::sleep_for(std::chrono::seconds(getEatTime()));std::cout<< id<< " all done eating."<< std::endl;permits.release();left.unlock();right.unlock();
}void philosopher(size_t id, std::mutex& left, std::mutex& right, std::counting_semaphore<N - 1>& permits){for(size_t i = 0; i < 3; ++i){think(id);eat(id, left, right, permits);}
}int main(){std::counting_semaphore<N - 1> permits(4);std::mutex forks[5];std::thread philosophers[5];for(size_t i = 0; i < 5; ++i){philosophers[i] = std::thread(philosopher, i, std::ref(forks[i]), std::ref(forks[(i + 1) % 5]), std::ref(permits));}for(auto& p:philosophers)p.join();return 0;
}

Leetcode1226

奇偶

class DiningPhilosophers {
public:const int N = 5;vector<mutex> forks;DiningPhilosophers():forks(N) {}void wantsToEat(int philosopher,function<void()> pickLeftFork,function<void()> pickRightFork,function<void()> eat,function<void()> putLeftFork,function<void()> putRightFork) {int left = philosopher, right = (philosopher + 1) % N;if(philosopher & 1){forks[left].lock();forks[right].lock();pickLeftFork();pickRightFork();}else{forks[right].lock();forks[left].lock();pickRightFork();pickLeftFork();}eat();putLeftFork();putRightFork();forks[left].unlock();forks[right].unlock();}
};

条件变量

其实就是模拟信号量

这里注意

[&cnt = cnt](){return cnt > 0;}

这个匿名函数需要C++14，低于14可以[this]，不然lambda搜索不到cnt

class Semaphore{
private:int cnt;mutex m;condition_variable_any cv;
public:Semaphore(int cnt):cnt(cnt){}void wait(){lock_guard<mutex> lg(m);cv.wait(m, [&cnt = cnt](){return cnt > 0;});--cnt;}void signal(){lock_guard<mutex> lg(m);++cnt;if(cnt == 1)cv.notify_all();}
};
class DiningPhilosophers {
public:const static int N = 5;vector<mutex> forks;Semaphore permits;DiningPhilosophers():forks(N), permits(N - 1) {}void wantsToEat(int philosopher,function<void()> pickLeftFork,function<void()> pickRightFork,function<void()> eat,function<void()> putLeftFork,function<void()> putRightFork) {int left = philosopher, right = (philosopher + 1) % N;permits.wait();forks[left].lock();forks[right].lock();pickLeftFork();pickRightFork();eat();putLeftFork();putRightFork();permits.signal();forks[left].unlock();forks[right].unlock();}
};

信号量

需要C++20

class DiningPhilosophers {
public:const static int N = 5;vector<mutex> forks;counting_semaphore<N - 1> permits;DiningPhilosophers():forks(N), permits(N - 1) {}void wantsToEat(int philosopher,function<void()> pickLeftFork,function<void()> pickRightFork,function<void()> eat,function<void()> putLeftFork,function<void()> putRightFork) {int left = philosopher, right = (philosopher + 1) % N;permits.acquire();forks[left].lock();forks[right].lock();pickLeftFork();pickRightFork();eat();putLeftFork();putRightFork();permits.release();forks[left].unlock();forks[right].unlock();}
};

https://web.stanford.edu/class/archive/cs/cs110/cs110.1204/static/lectures/10-threads-and-mutexes.pdf
https://blog.csdn.net/tomjobs/article/details/113921067