信号量实现生产者消费者模型

进化版的互斥锁（N）
由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时数据的正确性，但无形中导致线程的并发性下降，线程从并行执行变成串行
信号量，是一种相对折中的处理方式，既能保证同步，数据不混乱，又提高线程并发
主要函数：
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t *sem);

int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout); 绝对时间

int sem_post(sem_t *sem)

单生产者单消费者
//注意：函数返回值都没有检查，实际需要加上
#include <stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<semaphore.h>
#include<string.h>

#define MAXSIZE 10

//创建一个环形队列，用来让生产者和消费者访问
int queue[MAXSIZE];
int front;                      //队头
int rear;                       //队尾

//创建信号量
sem_t full;                     //已经放置的个数, 初始为0
sem_t empty;                    //空的个数, 初始为MAXSIZE


void *producer(void *arg){

    while(1){
        
        sem_wait(&empty);
        rear = (rear + 1) % MAXSIZE;
        queue[rear] = rand() % 100 + 10;
        sem_post(&full);
        printf("producer-------add %d\n", queue[rear]);

        sleep(rand() % 2);
    
    }
    return NULL;
}

void *consumer(void *arg){
    int p;

    while(1){

        sem_wait(&full);
        front = (front + 1) % MAXSIZE;
        p = queue[front];
        sem_post(&empty);
        printf("consumer--------eat %d\n", p);

        sleep(rand() % 5);
    }
    return NULL;
}

int main()
{
    pthread_t tpid;
    pthread_t tcid;
    srand(time(NULL));

    memset(queue, 0, sizeof(queue));
    front = rear = 0;

    sem_init(&full, 0, 0);                       //已经放置的个数, 初始为0
    sem_init(&empty, 0, MAXSIZE);                //空的个数, 初始为MAXSIZE

    pthread_create(&tpid, NULL, producer, NULL); //创建生产者线程
    pthread_create(&tcid, NULL, consumer, NULL); //创建消费者线程

    pthread_join(tpid, NULL);
    pthread_join(tcid, NULL);

    sem_destroy(&full);
    sem_destroy(&empty);

    return 0;
}