最近在进行多线程编程的学习，学习过程中想起了复习操作系统的时候见过的“哲学家吃饭问题”。当时理解并不算透彻。于是就趁这个机会，利用最近所学模拟一下这个过程吧。
一、问题描述
二、问题分析
哲学家就餐问题需要协调考虑两个问题：
1、不能让某个哲学家饿死；
2、要尽量提升吃饭的效率，也就是同一时间尽量让多一些哲学家吃饭（最多同时两个）。
我们考虑这两个问题，然后设计我们的策略。
我们可以考虑用五个互斥量来表示五把叉子，用五个整型来表示“盘子里剩下的面条还有多少”。
1、可能会导致死锁的一种最糟糕策略
某个哲学家的吃面步骤如下：
//while(true)
//{
// 思考;
// 给左边叉子上锁;//去拿左边叉子
// 给右边叉子上锁;//去拿右边叉子
// 吃面条;
// 给左边叉子解锁;//去拿左边叉子
// 给右边叉子解锁;//去拿右边叉子
//}
对于上面的代码，让我们考虑一种情况：如果某一时刻，所有哲学家都拿了自己左边的叉子，接下来他们都要去拿右边的叉子。此时，他们都会发现右边已经没有叉子了。但他们只有在吃完面条后才会放下自己左手的叉子，于是他们每个人左手拿着叉子面面相觑，都不愿意让出自己的叉子，陷入了死锁。因此，解决哲学家吃饭问题的关键点在于，如何避免死锁的发生。
如果每次只允许一个哲学家吃饭，那就可以确保不产生死锁。但理论上可以允许两个不相邻的哲学家同时吃面条，因此这种策略造成了叉子资源的浪费。
2、解决哲学家吃饭问题的一种思路
要解决哲学家就餐的问题，有一个基本的指导思想：放下叉子的时候，可以先放左边再放右边。但拿叉子的时候，要么不拿（缺了左边或右边的叉子），要么一次拿两把叉子！
问题来了，策略看起来很简单，但程序实现的关键点在于，如何模拟“同时拿起左右两把叉子，但凡少一个就不拿”？
（1）用五个互斥量模拟五把叉子
利用C++11中mutex类的try_lock成员函数。每个哲学家想要吃面条时，首先尝试拿起左手的叉子。如果能拿到，再尝试拿起右手的叉子。如果能拿到两把叉子，就吃面，吃完后释放两把叉子。如果无法拿到右边的叉子，就释放左边的叉子。假设一盘面条的数量为50，每个哲学家每次吃掉10到20的面条（随机），代码如下：
#include<iostream>
#include<thread>
#include<mutex>
#include<ctime>
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
//用五个互斥量表示五支叉子
mutex fork[5];
//用一个规模为5的整型数组来表示每个盘子剩余的面条
int nuddles[5] = { 50,50,50,50,50 };
//吃面条函数
void eat(int id) {
//id为哲学家编号
while (true) {
//尝试同时拿起左手边和右手边的叉子
if (fork[id].try_lock()) {
//先尝试拿起左手边的叉子
//如果能拿起左手边的叉子，再拿右手边的
if (fork[(id + 1) % 5].try_lock()) {
//如果也能拿起右手边的叉子，吃面条
//开吃，每次吃掉的面条数量为10-20之间的一个数字
printf("哲学家%d开始吃面条！\n", id + 1);
srand((unsigned)time(NULL));
int numbereated = rand() % (20 - 10 + 1) + 10;
sleep_for(seconds(numbereated % 10));//吃一段时间
nuddles[id] -= numbereated;
if (nuddles[id] <= 0) {
printf(" 哲学家%d吃完了他的所有面条！\n", id+1);
fork[id].unlock();
fork[(id + 1) % 5].unlock();
break;
}
printf("哲学家%d吃完，面条剩余%d!\n", id+1, nuddles[id]);
fork[id].unlock();
fork[(id + 1) % 5].unlock();
sleep_for(milliseconds(200));//吃完之后歇一会，让其它哲学家能够吃上
}
else {
//如果没办法拿起右手边的叉子，记得要把左手边的叉子放下来
fork[id].unlock();
sleep_for(milliseconds(100));//歇一会（思考），让其它哲学家能够吃上
}
}
}
}
int main()
{
printf("开始吃饭!每人拥有50面条\n");
thread t1(eat, 0);
thread t2(eat, 1);
thread t3(eat, 2);
thread t4(eat, 3);
thread t5(eat, 4);
t1.join(); t2.join(); t3.join(); t4.join(); t5.join();
printf("所有哲学家吃完！\n");
return 0;
}
程序运行结果如下：
上面的代码乍看起来是没问题的，但存在隐患。我们考虑一下，如果某一时刻，所有哲学家都拿了自己左边的叉子，接下来他们都要去拿右边的叉子。当这种情况发生时，他们都会发现右边已经没有叉子了。于是他们都把自己左边的叉子放回桌子。然后他们又发现左边有叉子，再拿起来，然后右边还是没有叉子，于是又放下，循环往复，还是陷入了死锁。这种情况虽然比较难遇到，但也不是不可能的。毕竟上面代码并没有遵循“当且仅当自己左边和右边的叉子都在的时候，才同时拿起两把叉子”这个原则。
（2）用临界区来实现“同时拿叉子”
要实现“同时拿两把叉子”这个操作，可以把“拿叉子”动作设为临界区。
#include<process.h>
#include<Windows.h>
#include<iostream>
#include<ctime>
using namespace std;
//用五个bool型变量表示五把叉子
//true表示可以拿，false表示已经被拿走
bool fork[5] = { true,true,true,true,true };
//用一个规模为5的整型数组来表示每个盘子剩余的面条
int nuddles[5] = { 50,50,50,50,50 };
//定义临界区结构为全局变量
CRITICAL_SECTION Section;
//拿叉子
bool takeForks(int id) {
//进入临界区，确保每个时刻只有一个哲学家在拿叉子
EnterCriticalSection(&Section);
bool leftfork = fork[id], rightfork = fork[(id + 1) % 5];
if (leftfork && rightfork) {
//同时拿起
fork[id] = false;
fork[(id + 1) % 5] = false;
}
LeaveCriticalSection(&Section);
return leftfork && rightfork;
}
//吃面条函数
void eat(void *param) {
int id = *(int*)param;
while (true) {
if (takeForks(id)) {
printf("哲学家%d开始吃面条！\n", id + 1);
srand((unsigned)time(NULL));
int numbereated = rand() % (20 - 10 + 1) + 10;
//Sleep((numbereated%10)*1000);
nuddles[id] -= numbereated;
if (nuddles[id] <= 0) {
printf(" 哲学家%d吃完了他的所有面条！\n", id + 1);
//EnterCriticalSection(&Section);
fork[id] = true;
fork[(id + 1) % 5] = true;
//LeaveCriticalSection(&Section);
break;
}
printf("哲学家%d吃完，面条剩余%d!\n", id + 1, nuddles[id]);
//EnterCriticalSection(&Section);
fork[id] = true;
fork[(id + 1) % 5] = true;
//LeaveCriticalSection(&Section);
Sleep(200);//思考
}
}
}
int main()
{
//初始化临界区
InitializeCriticalSection(&Section);
printf("开始吃饭!每人拥有50面条\n");
int p[5] = { 0,1,2,3,4 };
uintptr_t t1 = _beginthread(eat, 0, (void*)p);
uintptr_t t2 = _beginthread(eat, 0, (void*)(p + 1));
uintptr_t t3 = _beginthread(eat, 0, (void*)(p + 2));
uintptr_t t4 = _beginthread(eat, 0, (void*)(p + 3));
uintptr_t t5 = _beginthread(eat, 0, (void*)(p + 4));
HANDLE hArr[] = { (HANDLE)t1,(HANDLE)t2, (HANDLE)t3, (HANDLE)t4, (HANDLE)t5 };
WaitForMultipleObjects(5, hArr, TRUE, INFINITE);
printf("所有哲学家吃完！\n");
return 0;
}
3、解决哲学家吃饭问题的另一种思路：按编号从小到大的顺序拿叉子
作如下规定：每个哲学家不按照“先拿左边的叉子再拿右边的叉子”的顺序拿叉子，而是按照“先拿编号小的叉子，再拿编号大的叉子”。如果按照这个规则，对于题目给出的哲学家和叉子的编号，0到3号哲学家都会先拿左边再拿右边，但4号哲学家相反，是先拿右边再拿左边。这样就可以避免死锁的情况发生。
//while(true)
//{
// 思考;
// 给编号小的叉子上锁;
// 给编号大的叉子上锁;
// 吃面条;
// 给编号小的叉子解锁;
// 给编号大的叉子解锁;
//}
#include<iostream>
#include<thread>
#include<mutex>
#include<ctime>
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
//用五个互斥量表示五支叉子
mutex fork[5];
//用一个规模为5的整型数组来表示每个盘子剩余的面条
int nuddles[5] = { 50,50,50,50,50 };
//吃面条函数
void eat(int id) {
//id为哲学家编号
while (true) {
if (id < (id + 1) % 5) {
fork[id].lock();
fork[(id + 1) % 5].lock();
printf("哲学家%d开始吃面条！\n", id + 1);
srand((unsigned)time(NULL));
int numbereated = rand() % (20 - 10 + 1) + 10;
//sleep_for(seconds(numbereated % 10));//吃一段时间
nuddles[id] -= numbereated;
if (nuddles[id] <= 0) {
printf(" 哲学家%d吃完了他的所有面条！\n", id + 1);
fork[id].unlock();
fork[(id + 1) % 5].unlock();
break;
}
printf("哲学家%d吃完，面条剩余%d!\n", id + 1, nuddles[id]);
fork[id].unlock();
fork[(id + 1) % 5].unlock();
sleep_for(milliseconds(200));//吃完之后歇一会，让其它哲学家能够吃上
}
else {
fork[(id + 1) % 5].lock();
fork[id].lock();
printf("哲学家%d开始吃面条！\n", id + 1);
srand((unsigned)time(NULL));
int numbereated = rand() % (20 - 10 + 1) + 10;
//sleep_for(seconds(numbereated % 10));//吃一段时间
nuddles[id] -= numbereated;
if (nuddles[id] <= 0) {
printf(" 哲学家%d吃完了他的所有面条！\n", id + 1);
fork[(id + 1) % 5].unlock();
fork[id].unlock();
break;
}
printf("哲学家%d吃完，面条剩余%d!\n", id + 1, nuddles[id]);
fork[(id + 1) % 5].unlock();
fork[id].unlock();
sleep_for(milliseconds(200));//吃完之后歇一会（思考），让其它哲学家能够吃上
}
}
}
int main()
{
printf("开始吃饭!每人拥有50面条\n");
thread t1(eat, 0);
thread t2(eat, 1);
thread t3(eat, 2);
thread t4(eat, 3);
thread t5(eat, 4);
t1.join(); t2.join(); t3.join(); t4.join(); t5.join();
printf("所有哲学家吃完！\n");
return 0;
}
