线程同步模型的哲学家问题 C 的条件锁实现

产生死锁的四个必要条件：
（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;
}