多个生产者与多个消费者的问题

    在《UNIX网络编程 卷二》中看到了这个有关多个生产者与多个消费者的问题，书中指出多个消费者存在的意义需要看具体的应用程序。相对与多个生产者一个消费者的问题来说，我们需要额外的同步一下不同消费者之间的竞争。生产者则不需要作出任何改动，对于生产者来说所有的消费者是一个整体，反之对于消费者来说也是如此。

    这里我们论述的生产者与消费者问题是基于多线程环境下实现的，我们采用几个基于内存的POSIX信号量来实现同步。我们没有必要使用一个有名信号量来同步，因为我们要同步的是同一进程中不同的线程，直接使用基于内存的信号量就可以了。下面我们先看看实现的源码：

实现背景：有多个生产者和消费者，生产者负责将一个内存区域的内容填写上数字（从0开始递增），如果内存区域填满则从头开始填写数字（数字计数不归0），多个消费者负责校验生产者生产是否正确，这里我们选择的是直接将生产出的内容输出。

#include
#include
#include
#include
#include


#define NUM_PROD  10
#define NUM_CONS  5
#define BUFFSIZE  10000
#define TOTAL_NUM 100000


typedef pthread_t tid_t;


sem_t mutex_prod;
sem_t mutex_cons;
sem_t surplus;
sem_t yield;


int nput;
int nget;
int value;
int buff[BUFFSIZE];


void *produce(void *arg);
void *consume(void *arg);


int
main(int argc, char *argv[])
{
int   i;
int   num[NUM_PROD];
tid_t cons[NUM_CONS];
tid_t prod[NUM_PROD];


sem_init(&mutex_prod, 0, 1);
sem_init(&mutex_cons, 0, 1);
sem_init(&surplus, 0, BUFFSIZE);
sem_init(&yield, 0, 0);


for (i=0; inum[i] = 0;
pthread_create(prod+i, NULL, produce, (void *)(num+i));
}


for (i=0; ipthread_create(cons+i, NULL, consume, NULL);
}


for (i=0; i{
pthread_join(prod[i], NULL);
printf("ready\n");
}


for (i=0; ipthread_join(cons[i], NULL);
printf("done\n");
}


for (i=0; iprintf("produce[%d] = %d\n", i, num[i]);
}


sem_destroy(&mutex_prod);
sem_destroy(&mutex_cons);
sem_destroy(&surplus);
sem_destroy(&yield);


exit(0);
}


void *
produce(void *arg)
{
int *number = (int *)arg;


while (true) {
sem_wait(&surplus);
sem_wait(&mutex_prod);


if (TOTAL_NUM == nput) {
sem_post(&mutex_prod);
pthread_exit((void *)0);
}


buff[nput%BUFFSIZE] = value;
++nput;
++value;
++(*number);


sem_post(&mutex_prod);
sem_post(&yield);
}


pthread_exit((void *)0);
}


void *
consume(void *arg)
{
while (true) {
sem_wait(&mutex_cons);


if (TOTAL_NUM - 1 == nget) {
sem_post(&mutex_cons);
pthread_exit((void *)0);
}


sem_wait(&yield);


printf("nget = %d  buff[%d] = %d\n", nget, nget%BUFFSIZE, buff[nget%BUFFSIZE]);
++nget;


sem_post(&mutex_cons);
sem_post(&surplus);
}


pthread_exit((void *)0);
}

问题详解：首先我们要注意的是每一个生产者之间是互斥的，即同一时刻我们一般只允许一个生产者在生产，否则可能会带来更加麻烦的同步问题。我们不但要注意生产在之间的互斥问题，还要注意生产者只有在内存区域没有被写满的时候才能进行生产。对于每个消费者来说相互之间也是互斥的，消费者需要在有剩余产品的时候才能够继续消费。但是当所有生产者都离开的时候就会产生问题，所有的消费者都在等待生产而阻塞，这个问题处理只需要在等待生产者之前加一个判断就可以了，判断消费是否达到了生产的上限，如果达到了就退出，不过要注意在判断之前我们需要使用一个先号量保护。