生產者消費者問題是作業系統中的一個經典的問題。

他描述的是一個，多個生產者與多個消費者共享多個緩衝區的事情，具體的定義百度。

然後看了作業系統的書籍如何解決書上給的虛擬碼是這樣的

item B[k];
semaphore empty;    empty=k;   //可以使用的空緩衝區數
semaphore full; full=0;        //緩衝區內可以使用的產品數
semaphore mutex;    mutex=1;   //互斥訊號量
int in=0;                      //放入緩衝區指標
int out=0;                     //取出緩衝區指標 
 

cobegin
process producer_i ( ) {        process consumer_j( )   {    
       while(true) {                 while(true) {
       produce( );                   P(full);
       P(empty);                     P(mutex);
       P(mutex);                     take( ) from B[out];
       append to B[in];              V(empty);             
       in
 
=(in+1)%k;                  out=(out+1)%k;     
       V(mutex);                     V(mutex);  
       V(full);                      consume( );
                  }                               }
                    }                                }
coend

上面的註釋，和過程已經比較到位了，只是我習慣用我的方法，即把生產和消費，放入臨界區所以下面是我解決生產消費模型所用的虛擬碼

item B[k];
semaphore empty;    empty=k;   //可以使用的空緩衝區數
semaphore full; full=0;        //緩衝區內可以使用的產品數
semaphore mutex;    mutex=1;   //互斥訊號量
int in=0;                      //放入緩衝區指標
int out=0;                     //取出緩衝區指標 
cobegin
process producer_i ( ) {        process consumer_j( )   {    
       while(true) {                  while(true) {
       P(empty);                      P(full);
       P(mutex);                      P(mutex);
       produce( );                    take( ) from B[out];
       append to B[in];               consume( );               
       in=(in+1)%k;                   out=(out+1)%k;     
       V(mutex);                      V(mutex);  
       V(full);                       V(empty);
                  }                               }
                    }                                }
coend

好了說了這麼多我該帖下我的程式碼了，此程式碼在Linux環境下的多執行緒操作，用到了訊號量的。。。

#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)

#define CONSUMERS_COUNT 2   //消費者人數
#define PRODUCERS_COUNT 2   //生產者人數 
#define BUFFSIZE 5         

int g_buffer[BUFFSIZE];    //緩衝區數目

unsigned short in = 0;      //放入產品的指標（生產到哪個緩衝區）
unsigned short out = 0;     //取出緩衝區指標 （在哪個緩衝區消費的）
unsigned short produce_id = 0;     
unsigned short consume_id = 0;

sem_t g_sem_full; //可以使用的空緩衝區數（緩衝區中可以生產多少產品）
sem_t g_sem_empty;  //緩衝區內可以使用的產品數（可以消費的產品數）
pthread_mutex_t g_mutex;  //互斥訊號量

pthread_t g_thread[CONSUMERS_COUNT + PRODUCERS_COUNT];

void *consume(void *arg)
{
    int i;
    int num = (int)arg;
    while (1)
    {
        printf("%d wait buffer not empty\n", num);
        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("\t<--consume");

            printf("\n");
        }
        //produce()操作(生產產品)
        consume_id = g_buffer[out];
        printf("%d begin consume product %d\n", num, consume_id);
        g_buffer[out] = -1;
        //將取出緩衝區的指標偏移1（下個生產的位置）
        out = (out + 1) % BUFFSIZE;
        printf("%d end consume product %d\n", num, consume_id);
        pthread_mutex_unlock(&g_mutex);
        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\n", num);
        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("\t<--produce");

            printf("\n");
        }

        printf("%d begin produce product %d\n", num, produce_id);
        g_buffer[in] = produce_id;
        in = (in + 1) % BUFFSIZE;
        printf("%d end produce product %d\n", num, produce_id++);
        pthread_mutex_unlock(&g_mutex);
        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);

    for (i = 0; i < PRODUCERS_COUNT; i++)
        pthread_create(&g_thread[CONSUMERS_COUNT + i], NULL, produce, (void *)i);

    for (i = 0; i < CONSUMERS_COUNT + PRODUCERS_COUNT; i++)
        pthread_join(g_thread[i], NULL);

    sem_destroy(&g_sem_full);
    sem_destroy(&g_sem_empty);
    pthread_mutex_destroy(&g_mutex);

    return 0;
}

將程式執行，可得到這個結果