产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
通过条件变量的方式，引入一个 test 函数，在每个哲学家拿起筷子和放下筷子时检测自己是否可以吃东西，以及邻居有没有因为拿不到筷子而挂起，如果挂起则唤醒。
需要注意到一点是，在修改每个哲学家的state时需要加锁，因为这些是 share 的变量，为了保证这些变量在同一时间只有一个线程能够获得。
#include <stdio.h> // printf(),
#include <stdlib.h> // exit(), EXIT_SUCCESS
#include <pthread.h> // pthread_create(), pthread_join()
#include <semaphore.h> // sem_init()
#include <unistd.h>
#define PHILOSOPHER_COUNT 5
#define LEFT(p) ((p + 4) % PHILOSOPHER_COUNT)
#define RIGHT(p) ((p + 1) % PHILOSOPHER_COUNT)
enum
{
EATING,
THINKING,
HUNGRY
};
typedef struct
{
int tid;
pthread_cond_t cond;
int status;
} Philosopher, *Philosopher_p;
// table lock
pthread_mutex_t table_lock;
Philosopher_p ps;
int eating_count[PHILOSOPHER_COUNT];
void init_all_phill_status()
{
ps = (Philosopher_p)malloc(sizeof(Philosopher) * PHILOSOPHER_COUNT);
// Init global table lock
pthread_mutexattr_t lock_attr;
pthread_mutexattr_init(&lock_attr);
pthread_mutexattr_settype(&lock_attr, PTHREAD_MUTEX_ERRORCHECK);
// PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
// PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
// PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
// PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
pthread_mutex_init(&table_lock, &lock_attr);
for (int i = 0; i < PHILOSOPHER_COUNT; i++)
{
ps[i].status = THINKING;
pthread_cond_init(&ps[i].cond, NULL);
eating_count[i] = 0;
}
}
void test(int i)
{
pthread_mutex_lock(&table_lock);
if ((ps[LEFT(i)].status != EATING) && (ps[RIGHT(i)].status != EATING) && (ps[i].status == HUNGRY))
{
ps[i].status = EATING;
eating_count[i]++;
printf("p %d is eating now\n", i);
pthread_cond_signal(&ps[i].cond);
}
pthread_mutex_unlock(&table_lock);
}
void pickup(int i)
{
pthread_mutex_lock(&table_lock);
ps[i].status = HUNGRY;
test(i);
while (ps[i].status != EATING)
pthread_cond_wait(&ps[i].status, &table_lock);
pthread_mutex_unlock(&table_lock);
}
void putdown(int i)
{
pthread_mutex_lock(&table_lock);
ps[i].status = THINKING;
test(LEFT(i));
test(RIGHT(i));
printf("p %d is putdow now\n", i);
pthread_mutex_unlock(&table_lock);
}
void funct(int i)
{
while (1)
{
pickup(i);
sleep(1);
putdown(i);
sleep(1);
}
}
void print_count(){
while(1){
pthread_mutex_lock(&table_lock);
for(int i=0;i<PHILOSOPHER_COUNT;i++){
printf("p%d eat %d times; ",i,eating_count[i]);
}
printf("\n");
pthread_mutex_unlock(&table_lock);
sleep(5);
}
}
int main(int argc, char *argv[])
{
pthread_t threads[5];
init_all_phill_status();
// sem_init(&sem,0,5);
for (int i = 0; i < PHILOSOPHER_COUNT; i++)
{
pthread_create(threads + i, NULL, (void *)&request, i);
}
pthread_t tid;
pthread_create(&tid, NULL, (void *)&print_count, NULL);
for (int i = 0; i < PHILOSOPHER_COUNT; i++)
{
pthread_join(threads[i], NULL);
}
pthread_join(tid, NULL);
return 0;
}
