#include <semaphore.h>

int ReaderCount = 0; // 读者计数器
sem_t WriteMutex; // 写者访问控制信号量
sem_t CountMutex;  // 读者计数器访问控制信号量，是! 计数器!

// 初始化信号量
sem_init(&WriteMutex, 0, 1);  // 第二个参数是用于控制信号量的线程间共享
sem_init(&CountMutex, 0, 1);

void* writer(void* arg) {
    sem_wait(&WriteMutex);
    write();  // 写操作
    sem_post(&WriteMutex);
}

void* reader(void* arg) {
    sem_wait(&CountMutex);
    if (ReaderCount == 0) {
        sem_wait(&WriteMutex);
    }
    ReaderCount++;
    sem_post(&CountMutex);

    read();  // 读操作

    sem_wait(&CountMutex);
    ReaderCount--;
    if (ReaderCount == 0) {
        sem_post(&WriteMutex);
    }
    sem_post(&CountMutex);
}

#define N (5)  // 哲学家个数

void philosopher(int i) {  // 哲学家编号：0-4
    while (true) {
        think();                 // 哲学家在思考
        take_fork(i);            // 去拿左边的叉子
        take_fork((i + 1) % N);  // 去拿右边的叉子
        eat();                   // 进餐
        put_fork(i);             // 放下左边的叉子
        put_fork((i + 1) % N);   // 放下右边的叉子
    }
}

void philosopher(int i) {
    while (true) {
        think();
        while (true) {
            take_fork(i);
            if (fork((i + 1) % N)) {  // 右边的叉子还在吗
                take_fork((i + 1) % N);
                break;
            } else {
                put_fork(i);       // 放下左边的叉子
                wait_some_time();  // 等待一会儿
            }
        }
        eat();
        put_fork(i);
        put_fork((i + 1) % N);
    }
}

semaphore mutex = 1;  // 互斥信号量，初值为 1

void philosopher(int i) {
    while (true) {
        think();
        P(mutex);  // 进入临界区
        take_fork(i);
        take_fork((i + 1) % N);
        eat();
        put_fork(i);
        put_fork((i + 1) % N);
        V(mutex);  // 退出临界区
    }
}

#include <pthread.h>
#include <semaphore.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

#define N (5)
#define LEFT(i) (((i) + N - 1) % N)  // 左邻居
#define RIGHT(i) (((i) + 1) % N)     // 右邻居

#define EAT_MAX_NR (10)  // 每个哲学家允许的最大进餐次数，控制线程退出

typedef enum philo_state { THINKING = 0, HUNGARY, EATING } philo_state_en;

sem_t sem_mutex;      // 互斥信号量，初值为 1
int state[N];         // 哲学家状态
sem_t sem_sync[N];    // 同步信号量，初值为 0
pthread_t thread[N];  // 哲学家对应的线程

int eatNr[N];  // 哲学家进餐次数

/* 哲学家思考，随机思考一段时间 */
void think(int i) {
    printf("philo-%d, think start at %ld\r\n", i, clock());
    sleep(1 + rand() % 5);
    printf("philo-%d, think end at %ld\r\n", i, clock());
}

/* 哲学家就餐，吃一会儿 */
void eat(int i) {
    printf("philo-%d, eat start at %ld\r\n", i, clock());
    sleep(1 + rand() % 5);
    printf("philo-%d, eat end at %ld\r\n", i, clock());
    eatNr[i]++;
}

/* 检查当前哲学家是否可以进餐 */
void test_take_lr_forks(int i) {
    if (state[i] == HUNGARY && state[LEFT(i)] != EATING && state[RIGHT(i)] != EATING) {
        state[i] = EATING;
        // 若能拿到叉子，执行 V 操作，后续就不会阻塞
        sem_post(&sem_sync[i]);
    }
}

/* 尝试拿叉子（不一定能达到） */
void take_forks(int i) {
    sem_wait(&sem_mutex);
    state[i] = HUNGARY;
    test_take_lr_forks(i);
    sem_post(&sem_mutex);
    // 如果没拿到叉子，就会在这里阻塞，如果拿到了叉子，这里不会阻塞
    sem_wait(&sem_sync[i]);
}

/* 就餐完毕，尝试唤醒邻居就餐 */
void put_forks(int i) {
    sem_wait(&sem_mutex);
    state[i] = THINKING;
    test_take_lr_forks(LEFT(i));
    test_take_lr_forks(RIGHT(i));
    sem_post(&sem_mutex);
}

/* 哲学家线程：思考 - 拿叉子 - 就餐 - 放叉子 */
void philosopher(int i) {
    printf("Thread #%lu, phiol-%d in place\r\n", pthread_self(), i);
    while (true) {
        think(i);
        take_forks(i);
        eat(i);
        put_forks(i);
        if (eatNr[i] >= EAT_MAX_NR) {  // 控制线程退出
            pthread_exit(NULL);
        }
    }
}

int main(int argc, char* argv[]) {
    /* 初始化 */
    sem_init(&sem_mutex, 0, 1);
    for (int i = 0; i < N; i++) {
        state[i] = THINKING;
        eatNr[i] = 0;
        sem_init(&sem_sync[i], 0, 0);
    }

    /* 创建线程，并绑定线程函数 */
    for (int i = 0; i < N; i++) {
        pthread_create(&thread[i], NULL, (void* (*)(void*))philosopher, (void*)(uintptr_t)i);
    }

    /* 等待线程结束 */
    for (int i = 0; i < N; i++) {
        pthread_join(thread[i], NULL);
    }

    /* 销毁信号量 */
    sem_destroy(&sem_mutex);
    for (int i = 0; i < N; i++) {
        sem_destroy(&sem_sync[i]);
    }

    return 0;
}