生产者-消费者问题

设计任务: 利用信号量解决生产者-消费者问题
 解决方案
 生产者－消费者问题是典型的进程同步问题， 其本质是如何控制并发进
程对有界共享区的访问.
 生产者进程生产产品，然后将产品放置在一个空缓冲区中供消费者进程
消费.
 消费者进程从缓冲区中获得产品，然后释放缓冲区.
 当生产者进程生产产品时，如果没有空缓冲区可用，那么生产者进程必
须阻塞，等待消费者进程释放出一个空缓冲区.
 当消费者进程消费产品时，如果没有满的缓冲区，那么消费者进程将被
阻塞，直到新的产品被生产出来
 

#include <iostream>
#include <cstdio>
#include <pthread.h>
#include <malloc.h>
#include <semaphore.h>
using namespace std;
#define SIZE 10
int buff[SIZE];
int *pc=buff;
pthread_mutex_t mutex;
sem_t signal_produce;
sem_t signal_consume;
int n,m;
void* produce(void *)
{
    sem_wait(&signal_produce);
    pthread_mutex_lock(&mutex);
    printf("生产者装入 %ld\n",pc-buff);
    *pc=1;
    pc++;
    pthread_mutex_unlock(&mutex);
    sem_post(&signal_consume);
}
void* consume(void *)
{
    sem_wait(&signal_consume);
    pthread_mutex_lock(&mutex);
    pc--;
    *pc=0;
    printf("消费者取走 %ld\n",pc-buff);
    pthread_mutex_unlock(&mutex);
    sem_post(&signal_produce);
}
int main(int argc, char const *argv[]) {
    printf("请输入生产者个数: ");
    scanf("%d",&n);
    printf("请输入消费者个数: ");
    scanf("%d",&m);
    pthread_t* thread_producer=(pthread_t*)malloc(sizeof(pthread_t)*(n+1));
    pthread_t* thread_consumer=(pthread_t*)malloc(sizeof(pthread_t)*(m+1));
    pthread_mutex_init(&mutex,NULL);
    sem_init(&signal_produce,0,SIZE);
    sem_init(&signal_consume,0,0);
    for(int i=1;i<=SIZE;i++)
    buff[i]=1;
    for(int i=1;i<=n;i++)
    pthread_create(&thread_producer[i],NULL,produce,NULL);
    for(int i=1;i<=m;i++)
    pthread_create(&thread_consumer[i],NULL,consume,NULL);
    for(int i=1;i<=n;i++)
    pthread_join(thread_producer[i],NULL);
    for(int i=1;i<=m;i++)
    pthread_join(thread_consumer[i],NULL);
    free(thread_producer);
    free(thread_consumer);
    pthread_mutex_destroy(&mutex);
    sem_destroy(&signal_produce);
    sem_destroy(&signal_consume);
    return 0;
}