生产者消费者

生产着生产的由消费者消费，只有生产者生产了，消费者才能消费

一个进程代表生产者，一个进程代表消费者，一片内存代表中介，生产者生产的物品从一端放入内存，消费者从其中获取物品

使用信号量和互斥锁，代码示例：

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

#define BUFF_MAX 10
#define SC_NUM 2//生产者
#define XF_NUM 3//消费者

sem_t empty;		  //空信号量
sem_t full;			  //满信号量
pthread_mutex_t mutex;//锁

int buff[BUFF_MAX];
int in=0;
int out =0;

void* sc_thread(void* arg)
{
    int index=(int)arg;
    for(int i=0;i<30;i++)//生产者一个生产30个
    {
        sem_wait(&empty);//检查是否有空闲空间
        pthread_mutex_lock(&mutex);//加锁
        buff[in]=rand()%100;
        printf("第%d个生产者，产生了%d数据，在%d位置\n",index,buff[in],in);
        in=(in+1)%BUFF_MAX;//防止越界
        pthread_mutex_unlock(&mutex);
        sem_post(&full);
        
        int n=rand()%10;
        sleep(n);
    }
}
void* xf_thread(void* arg)
{
    int index=(int)arg;
    for(int i=0;i<20;i++)//消费者一个消费20个
    {
        sem_wait(&full);//检查是否有数据
        pthread_mutex_lock(&mutex);//加锁
        printf("第%d个消费者，读取了%d数据，在%d位置\n",index,buff[out],out);
        out=(out+1)%BUFF_MAX;//防止越界
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);
        
        int n=rand()%10;
        sleep(n);
    }
}
int main()
{
    //初始化
    sem_init(&empty,0,BUFF_MAX);
    sem_init(&full,0,0);
    pthread_mutex_init(&mutex,NULL);
    
    srand((int)time(NULL));//当前时间不同，随机数不同
        
    pthread_t sc_id[SC_NUM];
    pthread_t xf_id[XF_NUM];
    
    for(int i=0;i<SC_NUM;i++)//创建生产者
    {
        pthread_create(&sc_id[i],NULL,sc_thread,(void*)i);
    }
    
    for(int i=0;i<XF_NUM;i++)//创建消费者
    {
        pthread_create(&xf_id[i],NULL,xf_thread,(void*)i);
    }
    
    for(int i=0;i<SC_NUM;i++)
    {
        pthread_join(&sc_id[i],NULL);
    }
    
    for(int i=0;i<XF_NUM;i++)
    {
        pthread_join(&xf_id[i],NULL);
    }
    sem_destroy(&empty);
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);
    
    printf("main \n");
    return 0;
}