Linux生产者和消费者模型 条件变量 信号量

/*
    条件变量类型 pthread_cond_t
    int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
    int pthread_cond_destory(pthread_cond_t * cond);
    int pthread_cond_wait(pthread_cond_t *restrict cond, const pthread_mutex_t *restrict mutex);
        阻塞函数，调用了该函数，线程阻塞
    int pthread_cond_timewait(pthread_cond_t *restrict cond, const pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
        等待多长时间，调用了该函数，线程阻塞直至时间结束
    int pthread_cond_signal(pthread_cond_t * cond);
        唤醒至少一个等待的线程
    int pthread_cond_broadcast(pthread_cond_t * cond);
        唤醒所有等待的线程
*/


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

pthread_mutex_t mutex;

pthread_cond_t cond;
struct Node
{
    /* data */
    int num;
    struct Node *next;
};

struct Node * head = NULL;


void * producer(void * arg) {
    while(1) {
        pthread_mutex_lock(&mutex);
        struct Node * newnode = (struct Node*) malloc(sizeof(struct Node));
        newnode->next = head;
        head = newnode;
        newnode->num = rand() % 1000;
        printf("add node, node num :%d, tid, %ld\n", newnode->num, pthread_self());
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
        usleep(100);
    }
    return NULL;
}

void * customer(void * arg) {
    while(1) {
        pthread_mutex_lock(&mutex);
        struct Node *temp = head;
        if(head != NULL) {
            head = head->next;
            printf("delete node,num:%d, tid:%ld\n", temp->num, pthread_self());
            free(temp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        } else {
            pthread_cond_wait(&cond, &mutex);
            pthread_mutex_unlock(&mutex);
        }
        
    }
    return NULL;
}

int main() {
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_t ptids[5], ctids[5];

    for(int i = 0; i < 5; i++) {
        pthread_create(&ptids[i], NULL, producer,NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    pthread_exit(NULL);

    return 0;
}

/*
    #include <semaphore.h>
    函数量类型：sem_t
    int sem_init(sem_t *sem, int pshared, unsigned int value);
    参数：
        -sem 需要初始化的信号量的地址
        -pshared 表示用在进程还是线程之间 0 线程  非0 进程
        -value：记录信号量中的值

    int sem_destory(sem_t *sem);
        释放资源
    int sem_wait(sem_t *sem);
        对信号量的值减一，如果值为零，就阻塞
    int sem_trywait(sem_t *sem);
    int sem_timewait(sem_t *sem, const struct timespec *abs_timeout);
        等待多久的时间
    int sem_post(sem_t *sem);
        信号量的值加一
    int sem_getvalue(sem_t *sem, int *sval);
*/



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

pthread_mutex_t mutex;
sem_t psem;
sem_t csem;

struct Node
{
    /* data */
    int num;
    struct Node *next;
};

struct Node * head = NULL;


void * producer(void * arg) {
    while(1) {
        sem_wait(&psem);
        pthread_mutex_lock(&mutex);
        struct Node * newnode = (struct Node*) malloc(sizeof(struct Node));
        newnode->next = head;
        head = newnode;
        newnode->num = rand() % 1000;
        printf("add node, node num :%d, tid, %ld\n", newnode->num, pthread_self());
        pthread_mutex_unlock(&mutex);
        sem_post(&csem);
        usleep(100);
    }
    return NULL;
}

void * customer(void * arg) {
    while(1) {
        sem_wait(&csem);
        pthread_mutex_lock(&mutex);
        struct Node *temp = head;
        head = head->next;
        printf("delete node,num:%d, tid:%ld\n", temp->num, pthread_self());
        free(temp);
        pthread_mutex_unlock(&mutex);

        sem_post(&psem);
        usleep(100);
        
    }
    return NULL;
}

int main() {
    pthread_mutex_init(&mutex, NULL);
    sem_init(&psem, 0, 8);
    sem_init(&csem, 0, 0);

    pthread_t ptids[5], ctids[5];

    for(int i = 0; i < 5; i++) {
        pthread_create(&ptids[i], NULL, producer,NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);

    return 0;
}

可以把sem理解为车位，wait就占一个车位，pos就空一个车位，车位被占满就阻塞，直至有多余的空出来的。