#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

// 生产者信号量
sem_t semp;
// 消费者信号量
sem_t semc;
pthread_mutex_t mutex;

struct Node{
    int num;
    struct Node* next;
};
struct Node* head = NULL;
int cnt = 0;

void* producer(void* arg);
void* consumer(void* arg);

int main(int argc, char const *argv[])
{
    // 生产者，资源数量初始化为线程数，则有多少资源就有多少个线程执行
    sem_init(&semp, 0, 5);
    // 消费者，资源数量初始化为0，消费者线程启动就处于阻塞状态，因为开始的时候生产者还没有生产，消费者不能消费
    sem_init(&semc, 0, 0);
    pthread_mutex_init(&mutex, NULL);

    pthread_t t1[5], t2[5];

    for (size_t i = 0; i < 5; i++)
    {
        pthread_create(&t1[i], NULL, producer, NULL);
    }

    for (size_t i = 0; i < 5; i++)
    {
        pthread_create(&t2[i], NULL, consumer, NULL);
    }

    for (size_t i = 0; i < 5; i++)
    {
        pthread_join(t1[i], NULL);
        pthread_join(t2[i], NULL);
    }

    sem_destroy(&semp);
    sem_destroy(&semc);
    pthread_mutex_destroy(&mutex);

    return 0;
}

void* producer(void* arg){
    while(1){
        sem_wait(&semp);
        // 当涉及到>1个线程的信号量执行过程，线程锁需要放在信号量的下面。否则会产生死锁的风险。
        pthread_mutex_lock(&mutex);
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        //newNode->num = rand() % 1000;
        newNode->num = cnt++;
        newNode->next = head;
        head = newNode;
        printf("生产者 - id: %lu  num: %d\n", pthread_self(), newNode->num);
        pthread_mutex_unlock(&mutex);
        sem_post(&semc);
        sleep(rand()%3);
    }

    return NULL;
}

void* consumer(void* arg){
    while(1){
        sem_wait(&semc);
        pthread_mutex_lock(&mutex);
        struct Node* node = head;
        printf("\t\t消费者 -  id: %lu  num: %d\n", pthread_self(), node->num);
        head = head->next;
        free(node);
        cnt--;
        pthread_mutex_unlock(&mutex);
        sem_post(&semp);
        sleep(rand()%6);
    }
    
    return NULL;
}