生产者消费者伪码_五个同步问题的经典模型之一：生产者/消费者问题

也叫缓存绑定问题(bounded- buffer)，是一个经典的、多进程同步问题。

单生产者和单消费者

有两个进程：一组生产者进程和一组消费者进程共享一个初始为空、固定大小为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

");

}

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;

}