并行程序设计第4次作业——哲学家就餐问题

一、问题描述

五个沉默的哲学家围坐在一个圆桌旁，桌上放着几碗意大利面。叉子被放置在每一对相邻的哲学家之间。每个哲学家必须交替地思考和进餐。然而，哲学家只能在有左右叉子的情况下才能吃意大利面。每个叉子只能被一个哲学家拿着，所以一个哲学家只能在没有被另一个哲学家使用的情况下使用它。当一位哲学家吃完饭后，他们需要把两把叉子放下，这样其他人就可以享用这些叉子了。哲学家只能在他们有空的时候拿右手或左手的叉子，在拿两副叉子之前他们不能开始吃东西。每个哲学家有3种状态{thinking，trying，eating}。吃东西不受剩余的意大利面或胃空间的限制，假设有一个无限的供给和一个无限的需求。问题是如何设计一种行为准则(并发算法)，以确保没有哲学家挨饿；也就是说，每一种都可以永远在吃饭和思考之间交替，假设没有一个哲学家可以知道其他人什么时候可能想吃饭或思考。

二、概要设计

编程语言使用IEEE Posix Thread库与C语言实现。本次实验采用多线程解决哲学家就餐问题。由于哲学家的刀叉是共享变量，所以使用信号量实现互斥。线程个数(-n)即为哲学家个数，同时为每个叉子定义对应的信号量。每个哲学家在试图使用餐叉的时候需要先进行sem_wait，当拿到两个餐叉后，哲学家就能eating，eating完之后使用sem_post解锁这两个餐叉。

三、避免死锁的策略

method1：

解法：允许最多 thread_count - 1 个哲学家同时进入餐厅尝试获取餐叉，剩下的一个哲学家只有在有人吃完出去的时候才进去。这样就能保证起码有一个人能够同时获得两个餐叉，从而eating，避免大家都处于trying的状态。这种解法也能理解为引入一个餐厅服务生，哲学家必须经过他的允许才能拿起餐叉。当同时有 thread_count - 1 个餐叉被请求时，若是其他哲学家请求最后一个餐叉，服务生会让他等待。

实现方法：增加一个信号量sem_waiter，其初始值为thread_count - 1，每个线程trying时会先sem_wait(&sem_waiter)，在请求到两个餐叉并且eating后，再解锁两个叉子并使用sem_post(&sem_waiter)通知服务生。

method2：

解法：使用非对称解决方案。即单号的哲学家先拿起左边的叉子，接着右边的叉子；而双号的哲学家先拿起右边的叉子，接着左边的叉子。

实现方法：获取当前线程的编号，如果是奇数号线程就先请求左边的餐叉，然后请求右边的餐叉；如果是偶数好线程就先请求右边的餐叉，然后请求左边的餐叉。

四、实验

编译：gcc -g -Wall -o philosopher philosopher.c -lpthread

运行：./philosopher -normal n 哲学家个数 ./philosopher -method1 n 哲学家个数 ./philosopher -method2 n 哲学家个数

五、分析

1. -normal

正常状态下哲学家遵守以下规则：

哲学家在左边的叉子可用(没有其他人拿起)之前处于思考状态。如果左边的叉子可用，就拿起来。

哲学家等待右边的叉子可用。如果右边的叉子可用，就拿起来。

如果两个叉子都已经拿起来，开始吃意大利面，每次吃面都花费同样的时间。

吃完后先放下左边的叉子。

然后放下右边的叉子。

开始思考(进入一个循环)

但这种解法是失败的，当每个哲学家都拿起左侧的叉子，等待右侧的叉子可用时，就会进入死锁状态，每个哲学家将永远都在等待(右边的)另一个哲学家放下叉子。

2. -method1

至多只允许四个哲学家同时进餐，以保证至少有一个哲学家能够进餐，最终总会释放出他所使用过的两支筷子，从而可使更多的哲学家进餐。以下将sem_waiter作为信号量，只允许thread_count - 1个哲学家同时进入餐厅就餐，这样就能保证至少有一个哲学家可以就餐，而申请进入餐厅的哲学家进入sem_waiter的等待队列，根据FIFO的原则，总会进入到餐厅就餐，因此不会出现饿死和死锁的现象。

3.-method2

规定奇数号的哲学家先拿起他左边的筷子，然后再去拿他右边的筷子；而偶数号的哲学家则相反。按此规定，将是1、2号哲学家竞争1号筷子，3、4号哲学家竞争3号筷子。即五个哲学家都竞争奇数号筷子，获得后，再去竞争偶数号筷子，最后总会有一个哲学家能获得两支筷子而进餐。而申请不到的哲学家进入阻塞等待队列，根FIFO原则，则先申请的哲学家会较先可以吃饭，因此不会出现饿死的哲学家。

六、源代码

#include

#include

#include

#include

#include

#include

long thread_count; //线程个数，即哲学家个数

sem_t *sem_fork; //定义一组餐叉的信号量

sem_t sem_waiter; //method1中用到的信号量，用于确保至少一个人不能进餐

void *Philo_normal(void *rank); //一般方法，会陷入死锁

void *Philo_method1(void *rank); //方法1，服务生方法

void *Philo_method2(void *rank); //方法2，非对称解决方案

int main(int argc, char *argv[])

{

long thread;

pthread_t *thread_handles;

//获取线程个数，本实验中也代表哲学家人数

thread_count = strtol(argv[2], NULL, 10);

thread_handles = malloc (thread_count * sizeof(pthread_t));

sem_fork = malloc (thread_count * sizeof(sem_t));

//初始化waiter信号量

sem_init(&sem_waiter, 0, thread_count-1);

//初始化所有叉子信号量

for(long i = 0; i < thread_count; i ++ ){

sem_init(&sem_fork[i], 0, 1);

}

//创建线程

for(thread = 0; thread < thread_count; thread++ ){

//根据参数进入相应的处理函数

if(strcmp(argv[1], "-normal") == 0)

pthread_create(&thread_handles[thread], NULL, Philo_normal, (void *)thread);

else if(strcmp(argv[1], "-method1") == 0)

pthread_create(&thread_handles[thread], NULL, Philo_method1, (void *)thread);

else if(strcmp(argv[1], "-method2") == 0)

pthread_create(&thread_handles[thread], NULL, Philo_method2, (void *)thread);

}

//停止线程

for(thread = 0; thread < thread_count; thread ++ )

pthread_join(thread_handles[thread], NULL);

//销毁餐叉信号量

for(long i = 0; i < thread_count; i ++ ){

sem_destroy(&sem_fork[i]);

}

//销毁服务生信号量

sem_destroy(&sem_waiter);

//释放空间

free(thread_handles);

free(sem_fork);

return 0;

}

//一般方法，会陷入死锁

void *Philo_normal(void *rank)

{

long my_rank = (long)rank;

long my_left_fork, my_right_fork; //表示每个哲学家左右的叉子

my_left_fork = my_rank;

my_right_fork = (my_rank + 1) % thread_count;

while(1){

printf("Philosopher %ld is thinking\n", my_rank);

//把进程挂起一段时间， 单位是微秒(百万分之一秒)；

//usleep( (rand()%91 + 10)*1000 );

//本来应该随机挂起10-100ms,这里为了更快的检测死锁，将时间改为固定的50ms

usleep(50);

printf("Philosopher %ld is trying\n", my_rank);

sem_wait(&sem_fork[my_left_fork]);

sem_wait(&sem_fork[my_right_fork]);

printf("Philosopher %ld is eating\n", my_rank);

//usleep( (rand()%91 + 10)*1000 );

usleep(100);

sem_post(&sem_fork[my_left_fork]);

sem_post(&sem_fork[my_right_fork]);

}

}

//方法1，服务生方法

void *Philo_method1(void *rank)

{

long my_rank = (long)rank;

//哲学家左右的叉子

long my_left_fork, my_right_fork;

my_left_fork = my_rank;

my_right_fork = (my_rank + 1) % thread_count;

while(1){

printf("Philosopher %ld is thinking\n", my_rank);

//usleep( (rand()%91 + 10)*1000 ); //think 10-100 ms

usleep(50);

printf("Philosopher %ld is trying\n", my_rank);

//添加一个waiter信号量确保每个时刻最少一个人没有进去就餐

sem_wait(&sem_waiter);

sem_wait(&sem_fork[my_left_fork]);

sem_wait(&sem_fork[my_right_fork]);

printf("Philosopher %ld is eating\n", my_rank);

//usleep( (rand()%91 + 10)*1000 ); //eating 10-100 ms

usleep(100);

sem_post(&sem_fork[my_left_fork]);

sem_post(&sem_fork[my_right_fork]);

sem_post(&sem_waiter);

}

}

//方法2，非对称解决方案

void *Philo_method2(void *rank)

{

long my_rank = (long)rank;

//表示哲学家左右的叉子

long my_left_fork, my_right_fork;

//奇数先左叉后右叉，偶数先右叉后左叉

if(my_rank % 2 == 1){

my_left_fork = (my_rank + 1) % thread_count;

my_right_fork = my_rank;

}

else{

my_left_fork = my_rank;

my_right_fork = (my_rank + 1) % thread_count;

}

while(1){

printf("Philosopher %ld is thinking\n", my_rank);

//usleep( (rand()%91 + 10)*1000 ); //think 10-100 ms

usleep(50);

printf("Philosopher %ld is trying\n", my_rank);

sem_wait(&sem_fork[my_left_fork]);

sem_wait(&sem_fork[my_right_fork]);

printf("Philosopher %ld is eating\n", my_rank);

//usleep( (rand()%91 + 10)*1000 ); //eating 10-100 ms

usleep(100);

sem_post(&sem_fork[my_left_fork]);

sem_post(&sem_fork[my_right_fork]);

}

}

七、参考