五个同步问题的经典模型之一：生产者/消费者问题_多个 产者进程和多个消费者进程共享 个初始为空、固定 为n的缓存(缓

单生产者和单消费者

有两个进程：一组生产者进程和一组消费者进程共享一个初始为空、固定大小为n的缓存（缓冲区）。生产者的工作是制造一段数据，只有缓冲区没满时，生产者才能把消息放入到缓冲区，否则必须等待，如此反复; 同时，只有缓冲区不空时，消费者才能从中取出消息，一次消费一段数据（即将其从缓存中移出），否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或者一个消费者从中取出消息。

问题的核心是：
1.要保证不让生产者在缓存还是满的时候仍然要向内写数据;
2.不让消费者试图从空的缓存中取出数据。

生产者和消费者对缓冲区互斥访问是互斥关系，同时生产者和消费者又是一个相互协作的关系，只有生产者生产之后，消费者才能消费，他们也是同步关系。

• 解决思路：对于生产者，如果缓存是满的就去睡觉。消费者从缓存中取走数据后就叫醒生产者，让它再次将缓存填满。若消费者发现缓存是空的，就去睡觉了。下一轮中生产者将数据写入后就叫醒消费者。
  不完善的解决方案会造成“死锁”，即两个进程都在“睡觉”等着对方来“唤醒”。

只有生产者和消费者两个进程，正好是这两个进程存在着互斥关系和同步关系。那么需要解决的是互斥和同步PV操作的位置。使用“进程间通信”，“信号标”semaphore就可以解决唤醒的问题：

我们使用了两个信号标：full 和 empty 。信号量mutex作为互斥信号量，它用于控制互斥访问缓冲池，互斥信号量初值为 1；信号量 full 用于记录当前缓冲池中“满”缓冲区数，初值为0。信号量 empty 用于记录当前缓冲池中“空”缓冲区数，初值为n。新的数据添加到缓存中后，full 在增加，而 empty 则减少。如果生产者试图在 empty 为0时减少其值，生产者就会被“催眠”。下一轮中有数据被消费掉时，empty就会增加，生产者就会被“唤醒”。

伪代码：

 
semaphore mutex=1; //临界区互斥信号量
semaphore empty=n;  //空闲缓冲区
semaphore full=0;  //缓冲区初始化为空
producer ()//生产者进程 
{
    while(1)
    {
        produce an item in nextp;  //生产数据
        P(empty);  //获取空缓冲区单元
        P(mutex);  //进入临界区.
        add nextp to buffer;  //将数据放入缓冲区
        V(mutex);  //离开临界区,释放互斥信号量
        V(full);  //满缓冲区数加1
    }
}
 
consumer ()//消费者进程
{
    while(1)
    {
        P(full);  //获取满缓冲区单元
        P(mutex);  // 进入临界区
        remove an item from buffer;  //从缓冲区中取出数据
        V (mutex);  //离开临界区，释放互斥信号量
        V (empty) ;  //空缓冲区数加1
        consume the item;  //消费数据
    }
}

该类问题要注意对缓冲区大小为n的处理，当缓冲区中有空时便可对empty变量执行P 操作，一旦取走一个产品便要执行V操作以释放空闲区。对empty和full变量的P操作必须放在对mutex的P操作之前。

1、若生产者进程已经将缓冲区放满，消费者进程并没有取产品，即 empty = 0，当下次仍然是生产者进程运行时，它先执行 P(mutex)封锁信号量，再执行 P(empty)时将被阻塞，希望消费者取出产品后将其唤醒。轮到消费者进程运行时，它先执行 P(mutex)，然而由于生产者进程已经封锁 mutex 信号量，消费者进程也会被阻塞，这样一来生产者进程与消费者进程都
将阻塞，都指望对方唤醒自己，陷入了无休止的等待。
2、若消费者进程已经将缓冲区取空，即 full = 0,下次如果还是消费者先运行，也会出现类似的死锁。
不过生产者释放信号量时，mutex、full 先释放哪一个无所谓，消费者先释放 mutex 还是 empty 都可以。

多生产者多消费者

在多个制造商和多个消费者出现的情况下就会造成拥护不堪的情况，会导致两个或多个进程同时向一个磁道写入或读出数据。要理解这种情况是如何出现的，我们可以借助于putItemIntoBuffer()函数。它包含两个动作：一个来判断是否有可用磁道，另一个则用来向其写入数据。如果进程可以由多个制造商并发执行，下面的情况则会出现：
1、 两个制造商为emptyCount减值；
2、 一个制造商判断缓存中有可用磁道；
3、 第二个制造商与第一个制造商一样判断缓存中有可用磁道；
4、 两个制造商同时向同一个磁道写入数据。

多个生产者向一个缓冲区中存入数据，多个生产者从缓冲区中取数据。这是有界缓冲区问题，队列改写，生产者们之间、消费者们之间、生产者消费者之间互相互斥。
共享缓冲区作为一个环绕缓冲区，存数据到尾时再从头开始。

• 我们使用一个互斥量保护生产者向缓冲区中存入数据。由于有多个生产者，因此需要记住现在向缓冲区中存入的位置。
• 使用一个互斥量保护缓冲区中消息的数目，这个生产的数据数目作为生产者和消费者沟通的桥梁。
• 使用一个条件变量用于唤醒消费者。由于有多个消费者，同样消费者也需要记住每次取的位置。

在选项中选择生产条目的数目，生产者的线程数目，消费者的线程数目。生产者将条目数目循环放入缓冲区中，消费者从缓冲区中循环取出并在屏幕上打印出来。
为了克服这个问题，我们需要一个方法，以确保一次只有一个制造商在执行调用函数。换个说法来讲，我们需要一个有“互斥信号标”（mutal exclusion）的“关键扇区”（critical section）。为了实现这一点，我们使用一个叫mutex二位信号标。因为一个二位信号标的值只能是1或0，只有一个进程能执行down(mutex)或up(mutex)。

代码：

 
#include "unp.h"
static const int NBUFF         = 10000;
static const int MAXNTHREADS = 100;
static int nitems;      //总共生产的条目数
static int buff[NBUFF]; //生产者向其中放数据，消费者从中取数据
 
static struct put//生产者使用的结构，向其中互斥的放数据
{
    pthread_mutex_t mutex;
    int nput;            //net position to put
    int nval;            //next value to store
} put  = 
{
PTHREAD_MUTEX_INITIALIZER
};
 
//记录缓冲区的状态，准备好的数目，消费者唯一关注的结构，当然生产者也会使用
static struct nready
{
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int nget;
    int nready;            //number ready for consumer
} nready = 
{
PTHREAD_MUTEX_INITIALIZER,  PTHREAD_COND_INITIALIZER
};//
 
void *produce(void*);
void *consume(void*);
 
int main(int argc, char **argv)
{
    if (argc != 4)
    {
        err_quit("Usage: a.out <#items> <#produce_nthreads>
                  <#consume_nthreads>");
    }
    nitems = atoi(argv[1]);
    int produce_nthreads = min(atoi(argv[2]), MAXNTHREADS);
    int consume_nthreads = min(atoi(argv[3]), MAXNTHREADS);
 
    //Solaris 2.6需要设置线程并发数
    //Set_concurrency(nthreads + 1);
 
    pthread_t tid_produce[MAXNTHREADS];
    for (int i = 0; i < produce_nthreads; ++i) 
    {
        Pthread_create(&tid_produce[i], NULL, produce, NULL);
    }
    pthread_t tid_consume[MAXNTHREADS];
    for (int i = 0; i < consume_nthreads; ++i)
    {
        Pthread_create(&tid_consume[i], NULL, consume, NULL);
    }
 
    //等待线程终止
    for (int i = 0; i < produce_nthreads; ++i)
    {
        Pthread_join(tid_produce[i], NULL);
    }
    for (int i = 0; i < consume_nthreads; ++i)
    {
        Pthread_join(tid_consume[i], NULL);
    }
 
    exit(0);
}
 
void *produce(void *arg)
{
    printf("producd\n");
 
    //多个生产者
    for ( ; ; )
    {
        Pthread_mutex_lock(&put.mutex);
        //已存了需要多的数
        if (put.nval >= nitems)
        {
            Pthread_mutex_unlock(&put.mutex);
            return NULL;
        }
        buff[put.nput] = put.nval;
        if (++put.nput >= NBUFF)
        {
            put.nput = 0;
        }
        ++put.nval;
        Pthread_mutex_unlock(&put.mutex);
 
        //当生产了数据后通知条件变量，应该使临界区尽量短，宁愿使用多个互斥量
        Pthread_mutex_lock(&nready.mutex);
        if (nready.nready == 0)
        {
            Pthread_cond_signal(&nready.cond);
        }
        ++nready.nready;
        Pthread_mutex_unlock(&nready.mutex);
    } //end for(;;)
    return NULL;
}
 
void *consume(void *argv)
{
    printf("consume\n");
 
    //多个消费者
    //只生产nitems个选项
    for ( ; ; )
    {
        Pthread_mutex_lock(&nready.mutex);
        //while避免虚假唤醒
        while (nready.nready == 0)
        {
            Pthread_cond_wait(&nready.cond, &nready.mutex);
        }
        //int ival = buff[nready.nget];
        //if (++nready.nget == NBUFF) {
        //    nready.nget = 0;
        //}
        if (++nready.nget >= nitems)
        {
       //nget比较的取值为1..nitems，当为nitems时少操作了一次，总共操作nitems次
            if (nready.nget == nitems)
            {
                printf("buff[%d] = %d\n", nready.nget - 1, 
                        buff[(nready.nget - 1) % NBUFF]);
            }
            Pthread_cond_signal(&nready.cond);
            Pthread_mutex_unlock(&nready.mutex);
            return NULL;
        }
        --nready.nready;
        Pthread_mutex_unlock(&nready.mutex);
 
        //仅仅读数据不许要互斥
        //if (buff[nready.nget - 1] != nready.nget - 1)
        {
            printf("buff[%d] = %d\n", nready.nget - 1, 
                    buff[(nready.nget - 1) % NBUFF]);
            //printf("buff[%d] = %d\n", nready.nget, 
                      buff[nready.nget]);
       //}
    } //end for(i:0..nitems)
    return NULL;
}