五个同步问题的经典模型之一:生产者/消费者问题

也叫缓存绑定问题(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 <#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;
}

参考资料:
5个经典的同步问题
经典进程同步问题1:生产者-消费者问题
多个生产者——多个消费者模型(互斥量条件变量实现)
生产者消费者模型你知道多少
秒杀多线程第十篇 生产者消费者问题
C++11 并发指南九(综合运用: C++11 多线程下四种生产者消费者模型详解)

推荐阅读更多精彩内容

  • 本文摘自汤小丹主编《计算机操作系统》(第三版)2.4 经典进程的同步问 在多道程序环境下,进程同步问题十分重要,也...
    刘帅_阅读 2,179评论 1 1
  • 进程的描述与控制 1.前趋图与程序执行1.1 前趋图介绍:描述程序先后执行顺序,又称为有向无循环图,可记为DAG(...
    孙梦翔阅读 163评论 0 1
  • demo下载 建议一边看文章,一边看代码。 声明:关于性能的分析是基于我的测试代码来的,我也看到和网上很多测试结果...
    Yasin的简书阅读 33,480评论 20 293
  • 有时候,我会想要去走走那一段路。 暮色黄昏,天空的颜色是我迷恋的那一种灰色调。暗暗的好像想要拥抱大地一样低低的压 ...
    情恋风尘阅读 48评论 0 0
  • 7 课堂上社辰由于坐在教室较后的座位且此课老师略不关注这边的缘故让其偷睡了片刻做了一个梦。作者李越前果然在不久后会...
    李越前阅读 40评论 0 1