操作系统 | PV操作七大经典问题生产者消费者读者写者哲学家进餐理发师理发睡觉和尚打水吸烟者吃水果

西皮呦

已于 2022-09-02 15:38:27 修改

阅读量1.5w

点赞数 52

分类专栏：操作系统文章标签：考研 408 操作系统

于 2021-12-30 13:55:32 首次发布

本文链接：https://blog.csdn.net/weixin_47187147/article/details/122235160

版权

操作系统专栏收录该内容

25 篇文章

订阅专栏

一、生产者消费者问题

生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。

该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。

生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常采用进程间通信的方法解决该问题。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。

该问题需要注意的几点：

在缓冲区为空时，消费者不能再进行消费
在缓冲区为满时，生产者不能再进行生产
消费者之间互斥，生产者之间互斥，但是生产者和消费者之间不影响
注意条件变量与互斥锁的顺序

假设缓冲区大小为k，生产者、消费者线程若干。生产者和消费者相互等效,只要缓冲池未满,生产者便可将消息送入缓冲池;只要缓冲池未空,消费者便可从缓冲池中取走一个消息。

items代表缓冲区已经使用的资源数，spaces代表缓冲区可用资源数
mutex min,mout代表互斥锁
Buf[k] 代表缓冲区，其内容类型为item
in、out代表第一个资源和最后一个资源

Semahore full,empty;
full.value = 0 ,empty = k;
Item Buff[k];
Mutex min,mout;
int in = 0,out = 0;

producer {
    while(1) {
        produce(&item);
        P(empty);       // 等待缓冲区有空闲位置， 在使用PV操作时，条件变量需要在互斥锁之前
        P(min);         // 保证在product时不会有其他product访问缓冲区

        putitem(Buff,in,item);  // 将新资源放到buf[in]位置 
        in = ( in + 1 ) % k;
        
        V(min);   // 唤醒的顺序可以不同
        V(full);  // 通知consumer缓冲区有资源可以取走
    }
}

consumer {
    while(1) {
        P(full);        // 等待缓冲区有资源可以使用
        P(mout);        // 保证在consume时不会有其他consumer访问缓冲区

        getitem(Buff,out,&item);
        out = ( out + 1 ) % 10;

        V(mout);        // 唤醒的顺序可以不同
        V(empty);       // 通知缓冲区有空闲位置

        comsum(item);
    }
}

以上所谈，生产者和消费者之间不影响。接下来请看缓冲区互斥的情况。

系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用。(注:这里的“产品”理解为某种数据)

生产者、消费者共享一个初始为空、大小为n的缓冲区。
缓冲区没满→生产者生产
只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待。
缓冲区没空→消费者消费
只有缓冲区不空时,消费者才能从中取出产品，否则必须等待。
缓冲区是临界资源，各进程必须互斥地访问。
为什么要互斥？

设想生产者消费者同时进入临界区（同时进入不是先后进入），假设num等于1，生产一个，消耗一个，实际上最后还是num等于1。

但若生产者在消费者之后退出，会把num加一变成2，反之num变成0，这就出问题了。

在他们眼里num都是1，但他们不知道他们两个已经构成冲突了。

semaphore mutex = 1;        //互斥信号量，实现对缓冲区的互斥访问
semaphore empty =n;         //同步信号量，表示空闲缓冲区的数量
semaphore full = 0;         //同步信号量,表示产品的数量，也即非空缓冲区的数量
producer ( ) 
{ 
    while(1) 
    { 
        生产一个产品 ; 
        P ( empty) ;       //消耗一个空闲缓冲区
        P ( mutex) ;       //实现互斥是 在同一进程 中进行一对 PV 操作
        把产品放入缓冲区 ; 
        V(mutex) ; 
        V(full) ;          //增加一个产品
    };
};

consumer ( ) 
{ 
    while(1) 
    { 
        P ( full) ;        //消耗一个产品（非空缓冲区）
        P ( mutex) ; 
        从缓冲区取出一个产品 ; 
        V(mutex) ; 
        V(empty) ;         //增加一个空闲缓冲区
        使用产品 ; 
    };
};

能否改变相邻P、V操作的顺序?

若此时缓冲区内已经放满产品，则empty=o，full=n。

则生产者进程执行①使mutex变为0，再执行②，由于已没有空闲缓冲区，因此生产者被阻塞。由于生产者阻塞，因此切换回消费者进程。消费者进程执行③，由于mutex为0，即生产者还没释放对临界资源的“锁”，因此消费者也被阻塞。

这就造成了生产者等待消费者释放空闲缓冲区，而消费者又等待生产者释放临界区的情况，生产者和消费者循环等待被对方唤醒,出现“死锁”。

同样的，若缓冲区中没有产品，即full=0，empty=n。按③④①的顺序执行就会发生死锁。

因此,实现互斥的P操作一定要在实现同步的P操作之后。

V操作不会导致进程阻塞，因此两个V操作顺序可以交换。

二、读者写者问题

问题描述：

有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。因此要求： ①允许多个读者可以同时对文件执行读操作； ②只允许一个写者往文件中写信息； ③任一写者在完成写操作之前不允许其他读者或写者工作； ④写者执行写操作前，应让已有的读者和写者全部退出。

两类进程：写进程、读进程

互斥关系：写进程 — 写进程、写进程 — 读进程。读进程与读进程不存在互斥问题。

其核心思想在于设置了一个计数器count用来记录当前正在访问共享文件的读进程数。

我们可以用count的值来判断当前进入的进程是否是第一个/最后一个读进程，从而做出不同的处理。

另外，对count变量的检查和赋值不能一气呵成导致了一些错误，如果需要实现“一气呵成”，自然应该想到用互斥信号量。

最后，还要认真体会我们是如何解决“写进程饥饿”问题的。

三、哲学家进餐问题

问题描述：一张圆桌上坐着 5 名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子（一根一根地拿起）。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。

由问题描述我们可以知道，一共有五个哲学家，也就是五个进程；五只筷子，也就是五个临界资源；因为哲学家想要进餐，必须要同时获得左边和右边的筷子，这就是要同时进入两个临界区（使用临界资源），才可以进餐。

因为是五只筷子为临界资源，因此设置五个信号量即可。

一个错误例子

定义互斥信号量数组 mutex[5]={1,1,1,1,1} 用于实现对 5 个筷子的互斥访问。

并对哲学家按 0~4 编号，哲学家 i 左边的筷子编号为 i ，右边的筷子编号为 ( i +1)%5 。

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量

void philosopher(int i){
  do {
    //thinking			//思考
    P(mutex[i]);        //判断哲学家左边的筷子是否可用
    P(mutex[(i+1)%5]);  //判断哲学家右边的筷子是否可用
    //...
    //eat		        //进餐
    //...
    V(mutex[i]);        //退出临界区，允许别的进程操作缓冲池
    V(mutex[(i+1)%5]);  //缓冲池中非空的缓冲区数量加1，可以唤醒等待的消费者进程
  }while(true);
}

我们来分析下上面的代码，首先我们从一个哲学家的角度来看问题，程序似乎是没有问题的，申请到左右两支筷子后，然后开始进餐。

但是如果考虑到并发问题，五个哲学家同时拿起了左边的筷子，此时，五只筷子立刻都被占用了，没有可用的筷子了，当所有的哲学家再想拿起右边筷子的时候，因为临界资源不足，只能将自身阻塞，而所有的哲学家全部都会阻塞，并且不会释放自己手中拿着的左边的筷子，每位哲学家循环等待右边的人放下筷子（阻塞），发生“死锁”。

回顾避免死锁的四个条件；

循环等待条件（互相持有资源而等待彼此的释放）
请求与保持条件
不可剥夺条件
互斥条件

因为，为了解决五个哲学家争用的资源的问题，我们可以采用以下几种解决方法：

① 至多只允许有四位哲学家同时去拿左边的筷子，最终能保证至少有一位哲学家能够进餐，并在用餐完毕后能释放他占用的筷子，从而使别的哲学家能够进餐；
② 仅当哲学家的左、右两支筷子可用时，才允许他拿起筷子；
③ 规定奇数号哲学家先拿他左边的筷子，然后再去拿右边的筷子；而偶数号哲学家则相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况。

下面我们对每种方法给出哲学家进程的伪代码。

解决哲学家进餐问题的三种方法

方法一：控制哲学家就餐数量（破坏循环等待条件）

对于方法一，至多只允许有四位哲学家同时去拿左边的筷子，我们可以简单的通过增加一个信号量实现，通过这个信号量限定哲学家并发去进餐的数量。

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量
semaphore count = 4;	//控制最多允许四位哲学家同时进餐

void philosopher(int i){
  do {
    //thinking		//思考
    p(count);		//判断是否超过四人准备进餐
    P(mutex[i]);	//判断缓冲池中是否仍有空闲的缓冲区
    P(mutex[(i+1)%5]);//判断是否可以进入临界区（操作缓冲池）
    //...
    //eat			//进餐
    //...
    V(mutex[i]);//退出临界区，允许别的进程操作缓冲池
    V(mutex[(i+1)%5]);//缓冲池中非空的缓冲区数量加1，可以唤醒等待的消费者进程
    V(count);//用餐完毕，别的哲学家可以开始进餐
  }while(true);
}

方法二：同时拿起左右的叉子（破坏请求与保持条件）

semaphore chopstick[5]={1,1,1,1,1}; 
semaphore mutex = 1 ;            // 互斥地取筷子 
Pi ( ) {                         //i 号哲学家的进程 
    while(1) 
    { 
        P ( mutex) ; 
        P ( chopstick[i] ) ;     // 拿左 
        P ( chopstick[ ( i+1) %5] ) ; // 拿右 
        V(mutex) ; 
        吃饭 … 
        V(chopstick[i] ) ;       // 放左 
        V(chopstick[ ( i+1) %5] ) ; // 放右 
        思考 … 
    } 
}

实际上，这种方法并不能保证只有两边的筷子都可用时，才允许哲学家拿起筷子。

更准确的说法应该是：各哲学家拿筷子这件事必须互斥的执行。这就保证了即使一个哲学家在拿筷子拿到一半时被阻塞，也不会有别的哲学家会继续尝试拿筷子。这样的话，当前正在吃饭的哲学家放下筷子后，被阻塞的哲学家就可以获得等待的筷子了。

第二种方法，也可以使用AND型信号量，同时对哲学家左右两边的筷子同时申请。下面是伪代码：

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量

void philosopher(int i){
  do {
    //thinking		//思考
    Swait(mutex[i], mutex[(i+1)%5]);//判断哲学家左边和右边的筷子是否同时可用
    //...
    //eat		
    //...
    Ssignal(mutex[i], mutex[(i+1)%5]);//进餐完毕，释放哲学家占有的筷子
  }while(true);
}

方法三：限定就餐策略（破坏死锁的循环等待条件）

对于第三种，需要在代码中添加个判断，来决定获取左、右筷子的顺序，其伪代码如下：

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量

void philosopher(int i){
  do {
    //thinking	
    if(i%2 == 1){
      P(mutex[i]);//判断哲学家左边的筷子是否可用
      P(mutex[(i+1)%5]);//判断哲学家右边的筷子是否可用
    }else{
      P(mutex[(i+1)%5]);//判断哲学家右边的筷子是否可用
      P(mutex[i]);//判断哲学家左边的筷子是否可用
    }
    //...
    //eat
    //...
    V(mutex[i]);//退出临界区，允许别的进程操作缓冲池
    V(mutex[(i+1)%5]);//缓冲池中非空的缓冲区数量加1，可以唤醒等待的消费者进程
  }while(true);
}

四、和尚打水问题(多生产者多消费者)

问题描述：

某寺庙，有小和尚和老和尚若干，有一个水缸，由小和尚提水入缸供老和尚饮用。水缸可以容纳10桶水，水取自同一口井中，由于水井口窄，每次只能容纳一个水桶取水。水桶总数为n个。每次入水、取水仅为一桶，且不可同时进行。

信号量设置：

1.对于水缸——以一个水桶水为单位，empty=10、full = 0两个计数信号量
小和尚对缸操作：mutex-jar = 1二元信号量；
水桶个数(资源数)：bucket = n计数信号量
取水操作(每次入水、取水仅为一桶)：互斥mutex-well = 1二元信号量；

伪代码：

五、吃水果问题(多生产者多消费者)

问题描述：桌上有一只盘子,最多可容纳一个水果,每次只能放入/取出一个水果。父亲专向盘子中放苹果(apple),母亲专向盘子中放橘子(orange),儿子专等吃盘子中的橘子,女儿专等吃盘子里的苹果。试设计信号量并使用P、V操作同步父,母、子、女进程。

互斥关系：对缓冲区（盘子）的访问要互斥地进行

同步关系（一前一后）：

1. 父亲将苹果放入盘子后，女儿才能取苹果
2. 母亲将橘子放入盘子后，儿子才能取橘子
3. 只有盘子为空时，父亲或母亲才能放入水果（“盘子为空”这个事件可以由儿子或女儿触发，事件发生后才允许父亲或母亲放水果）

注：

解决 “多生产者 - 多消费者问题”的关键在于理清复杂的同步关系。

在分析同步问题（一前一后问题）的时候不能从单个进程行为的角度来分析，要把 “一前一后”发生的事看做是两种 “事件” 的前后关系。

比如，如果从单个进程行为的角度来考虑的话，我们会有以下结论：

如果盘子里装有苹果，那么一定要女儿取走苹果后父亲或母亲才能再放入水果。如果盘子里装有橘子，那么一定要儿子取走橘子后父亲或母亲才能再放入水果。这么看是否就意味着要设置四个同步信号量分别实现这四个“一前一后”的关系了？

正确的分析方法应该从“事件”的角度来考虑，我们可以把上述四对“进程行为的前后关系” 抽象为一对事件的前后关系：盘子变空事件、放入水果事件。

“盘子变空事件” 既可由儿子引发，也可由女儿引发； “放水果事件” 既可能是父亲执行，也可能是母亲执行。这样的话，就可以用一个同步信号量解决问题了。

semaphore mutex = 1 ; // 实现互斥访问盘子（缓冲区） 
semaphore apple = 0 ; // 盘子中有几个苹果 
semaphore orange = 0 ; // 盘子中有几个橘子 
semaphore plate = 1 ; // 盘子中还可以放多少个水果

思考：可不可以不用互斥信号量mutex？

结论：即使不设置专门的互斥变量 mutex ，也不会出现多个进程同时访问盘子的现象。

原因在于：本题中的缓冲区大小为1，在任何时刻，apple、orange、plate三个同步信号量中最多只有一个是1。因此在任何时刻,最多只有一个进程的P操作不会被阻塞,并顺利地进入临界区...

如果缓冲区大小大于 1 ，就必须专门设置一个互斥信号量 mutex 来保证互斥访问缓冲区。

将上面代码有mutex的删去即可。

总结：

在生产者 - 消费者问题中，如果缓冲区大小为 1 ，那么有可能不需要设置互斥信号量就可以实现互斥访问缓冲区的功能。

当然，这不是绝对的，要具体问题具体分析。

建议：在考试中如果来不及仔细分析，可以加上互斥信号量，保证各进程一定会互斥地访问缓冲区。但需要注意的是，实现互斥的P操作一定要在实现同步的P操作之后，否则可能引起 “ 死锁。

六、吸烟者问题(单生产者多消费者)

问题描述：

假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料：烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地供三种材料，供应者每次将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者就会放另外两种材料再桌上，这个过程一直重复（让三个抽烟者轮流地抽烟）。

可生产多种产品的单生产者以及多消费者问题。

生产者可生产的产品一共有三种：

组合一：纸+胶水；

组合二：烟草+胶水；

组合三：烟草+纸。

互斥关系：桌子可以看作是一个容量为1的缓冲区，其访问是互斥的；

同步关系：（从事件的角度来分析）

桌上有组合一之后第一个抽烟者取走组合一；

桌上有组合二之后第二个抽烟者取走组合二；

桌上有组合三之后第三个抽烟者取走组合三；

取走东西使用完成后供应者将下一个组合放到桌子上。

伪代码：

吸烟者问题可以为我们解决“可以生产多个产品的单生产者”问题提供一个思路。

值得吸取的精华是： “轮流让各个吸烟者吸烟”必然需要“轮流的在桌上放上组合一、二、三”，注意体会我们是如何用一个整型变量 i 实现这个“轮流”过程的。

如果题目改为“每次随机地让一个吸烟者吸烟”，我们有应该如何用代码写出这个逻辑呢？ random

若一个生产者要生产多种产品（或者说会引发多种前驱事件），那么各个V操作应该放在各自对应的 “事件” 发生之后的位置。

七、理发师睡觉理发(单生产者多消费者)

问题描述：

假设有一个理发店只有一个理发师，一张理发时坐的椅子，若干张普通椅子顾客供等候时坐。没有顾客时，理发师就坐在理发的椅子上睡觉。顾客一到，他不是叫醒理发师，就是离开。如果理发师没有睡觉，而在为别人理发，他就会坐下来等候。如果所有的椅子都坐满了人，最后来的顾客就会离开。

在出现竞争的情况下问题就来了，这和其它的排队问题是一样的。实际上，与哲学家就餐问题是一样的。如果没有适当的解决方案，就会导致进程之间的“饿肚子”和“死锁”。
如理发师在等一位顾客，顾客在等理发师，进而造成死锁。另外，有的顾客可能也不愿按顺序等候，会让一些在等待的顾客永远都不能理发。

解决方案：
最常见的解决方案就是使用三个信号量（Semaphore）：

一个给顾客信号量，一个理发师信号量（看他自己是不是闲着），第三个是互斥信号量（Mutual exclusion，缩写成mutex）。

一位顾客来了，他想拿到互斥信号量，他就等着直到拿到为止。顾客拿到互斥信号量后，会去查看是否有空着的椅子（可能是等候的椅子，也可能是理发时坐的那张椅子）。
如果没有一张是空着的，他就走了。如果他找到了一张椅子，就会让空椅子的数量减少一张，这位顾客接下来就使用自己的信号量叫醒理发师。

这样，互斥信号标就释放出来供其他顾客或理发师使用。如果理发师在忙，这位顾客就会等。理发师就会进入了一个永久的等候循环，等着被在等候的顾客唤醒。一旦他醒过来，他会给所有在等候的顾客发信号，让他们依次理发。

semaphore customers = 0; 
semaphore barbers = 0;  
semaphore mutex = 1;  // 椅子是理发师和顾客进程都可以访问的临界区 
int chair = N;       //所有的椅子数量  

cobegin
process barber(){  
    While(true){        //持续不断地循环  
          P(customers); //试图为一位顾客服务，如果没有他就睡觉（进程阻塞）  
          P(mutex);     //如果有顾客，这时他被叫醒（理发师进程被唤醒），要修改空椅子的数量  
          chair++;      //一张椅子空了出来  
          V(barbers);  //现在有一个醒着的理发师，理发师准备理发.
                       //多个顾客可以竞争理发师互斥量，但是只有一个顾客进程被唤醒并得到服务  
          V(mutex);   //释放椅子互斥量，使得进店的顾客可以访问椅子的数量以决定是否进店等待 
          cut_hair();
    ｝  
}

process customer_i(){   
    P(mutex);     //想坐到一张椅子上  
    if (chair > 0){ 
        chair--;        //顾客坐到一张椅子上了  
        V(customers);   //通知理发师，有一位顾客来了  
        V(mutex);       //顾客已经坐在椅子上等待了，访问椅子结束，释放互斥量  
        P(barbers);     //该这位顾客理发了，如果理发师还在忙，那么他就等着（顾客进程阻塞）  
        get_haircut();  //顾客坐下剪头~
    }
    else  
        V(mutex);       //不要忘记释放被锁定的椅子,没椅子，顾客跑了。 
}
coend