POSIX信号量与互斥锁实现生产者消费者模型

posix信号量 Link with -lpthread.

sem_t *sem_open(const char *name, int oflag);//打开POSIX信号量
sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

int sem_init(sem_t *sem, int pshared, unsigned int value);

posix互斥锁（第七章）
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

有两个信号量。

p操作：测试信号量值大于0,减1.sem_wait
v操作：给定信号量值加1. sem_post
用posix信号量和互斥锁解决生产者消费者问题
一、生产者线程的任务：
p(sem_full)，p一个满的信号量（缓冲区容量），如果仓库还没满(sem_full>0),我们就能生产产品。一旦我们
生产了一个产品，仓库既不是一个空的状态了，我们V一个空的信号量sem_empty.就告诉了消费者可以消费了。
由于可能有多个生产者，所以引入一个互斥量。
二：消费者的任务：
要p(sem_empty),如果生产者没有V一个sem_empty，消费者p操作sem_empty可能就不行，所以要等生产者生产了产品，
v了sem_empty通知到消费者，消费者才可以消费。一旦消费了一个产品，就可以V(sem_full)是的仓库容量减一（不满）通知
到生产者线程又可以生产了。由于可能有多个消费者，所以引入一个互斥量。

假设仓库容量为10，刚开始可以生产产品，所以sem_full(10)信号量初始值设为10，表示可以生产10个。
刚开始仓库中没有产品可以消费，所以sem_empty(0)初始值为0.

#include<unistd.h>
#include<sys/types.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include <semaphore.h>
#include<pthread.h>
#define ERR_EXIT(m)
    do
    {
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)
#define CONSUMERS_COUNT  1    //消费者线程个数
#define PRODUCERS_COUNT  2    //生产者线程个数
#define BUFFSIZE 10              //缓冲区大小（仓库大小）
int g_buffer[BUFFSIZE];       //环形缓冲区
unsigned short in=0;        //初始生产产品放置位置
unsigned short out=0;        //初始消费的产品位置
unsigned short produce_id=0;//当前正在消费的产品ID
unsigned short consume_id=0;//当前正在消费的产品ID
//两个信号量，一个互斥锁。
sem_t g_sem_full;//可生产产品的数量
sem_t g_sem_empty;//可消费产品的数量
pthread_mutex_t g_mutex;

pthread_t  g_thread[CONSUMERS_COUNT+PRODUCERS_COUNT ];//线程ID.生产者线程个数+消费者线程个数
//消费者线程执行的任内务
void* consume(void*arg)
{
    int num=(int)arg;
    int i;
　　　　　//消费者不断消费
    while(1)
    {
        printf("%d  wait buffer not empty
",num);
    //sem_wait测试信号量值大于0减一并立即返回.P操作
        sem_wait(&g_sem_empty);
        pthread_mutex_lock(&g_mutex);
        //消费之前打印基本信息
        for(i=0;i<BUFFSIZE;i++)
            {
                printf("%02d  ",i);//仓库序号
                if(g_buffer[i]==-1)
                    printf("%s  ","null");//仓库为空
                else 
                    printf("%d  ",g_buffer[i]);
                if(i==out)
                    printf("	<--consume");//消费位置
                printf("
");
            }
        consume_id=g_buffer[out];
        printf("%d begin consume product %d
",num,consume_id);
        g_buffer[out]=-1;
        out=(out+1)%BUFFSIZE;
        printf("%d end consume product %d
",num,consume_id);
        pthread_mutex_unlock(&g_mutex);
        //给定信号量值加1。V操作,消费了一个产品，仓库就可以再生产产品
        sem_post(&g_sem_full);
        sleep(1);
    }    
    return NULL;
}
//生产者线程执行的任务。
void* produce(void*arg)
{    
    int num=(int)arg;
    int i;
    while(1)
    {
        printf("%d  wait buffer not full
",num);
        //sem_wait测试信号量值大于0减一并立即返回.g_sem_full代表可以生产的个数，生产了一个之后，可以生产的个数就要减一
        //所以初始值为buffersize
        sem_wait(&g_sem_full);
        pthread_mutex_lock(&g_mutex);
        //生产之前打印基本信息
        for(i=0;i<BUFFSIZE;i++)
        {
            printf("%02d  ",i);//仓库序号
            if(g_buffer[i]==-1)
                printf("%s  ","null");//仓库为空
            else 
                printf("%d  ",g_buffer[i]);
            if(i==in)
                printf("	<--produce");//生产位置
            printf("
");
        }
        printf("%d begin produce product %d
",num,produce_id);
        g_buffer[in]=produce_id;
        in=(in+1)%BUFFSIZE;
        printf("%d end produce product %d
",num,produce_id++);
        pthread_mutex_unlock(&g_mutex);
        //生产了一个产品的话，就给g_sem_empty信号量值加1
        sem_post(&g_sem_empty);
        sleep(5);
    }
    return NULL;
}
int main(void)
{
    int i;
    for(i=0;i<BUFFSIZE;i++)
        g_buffer[i]=-1;
    //初始化信号量
    sem_init(&g_sem_full,0,BUFFSIZE);
    sem_init(&g_sem_empty,0,0);
    //初始化互斥量
    pthread_mutex_init(&g_mutex,NULL);

    //创建若干个线程，执行消费任务。
    for(i=0;i<CONSUMERS_COUNT;i++)
    {
    pthread_create(&g_thread[i],NULL,consume,(void*)i);//产生了段错误.我们传递的是值，所以int num=(int)arg 而不是int num=*(int*)arg
    }
    //创建若干个线程，执行生产任务。
    for(i=0;i<PRODUCERS_COUNT;i++)
    {
        pthread_create(&g_thread[i+CONSUMERS_COUNT],NULL,produce,(void*)i);
    }
    //主线程等待这些线程结束
    for(i=0;i<CONSUMERS_COUNT+PRODUCERS_COUNT;i++)
    {
        pthread_join(g_thread[i],NULL);
    }
    
    sem_destroy(&g_sem_full);//销毁POSIX信号量
    sem_destroy(&g_sem_empty);
    pthread_mutex_destroy(&g_mutex);
    return 0;
}