18-典型进程问题

典型进程问题

生产者-消费者

#专业课

问题描述

系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区取出一个产品并使用。
生产者、消费者共享一个初始为空，大小为n的缓冲区。

1. 只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待。[同步关系]
2. 只要缓冲区不空时，消费者才能从中取出产品，否则必须等待
3. 缓冲区是临界资源，各个进程必须互斥的访问。[互斥]

问题实现

步骤分析

1. 关系分析，找出题目中描述的各个进程，分析他们之间的同步、互斥关系。
2. 整理思路根据各个进程的流程确定P,V操作的大致流程
   1. 生产者每次要消耗§一个空闲缓冲区，并生产(V)一个产品
   2. 消费者每次要消耗§一个产品，并释放一个空闲缓冲区
   3. 往缓冲区放入/取走产品需要互斥
3. 设置信号量，设置需要的信号量，并根据题目条件确定信号量初值
   1. 互斥信号量初值一般为1
   2. 同步信号量初始值一般看资源的初始值

代码实现

semaphore mutex=1;//互斥信号量，实现对缓冲区的互斥访问
semaphore empty=n;//同步信号量，表示空闲缓冲区的数量
semaphore full=0; //同步信号量，表示产品的数量
-----------------------------------------------------
//生产者
producer(){
	while(1){
	生产一个产品
	P(empty);
	P(mutex);
	把产品放入缓冲区
	V(mutex);
	V(full);
	
	}
}
-----------------------------------------------------
//消费者
consumer(){
	while(1){
	P(full);
	P(mutex);
	使用产品
	V(mutex);  
	V(empty);
	}
}

思考是否能改变互斥操作

实现互斥的P操作一定要在实现同步的P操作之后
V操作不会导致进程阻塞,因此两个V操作的顺序可以互换

---

多生产者-多消费者问题

问题描述

桌子上有一只盘子，每次只能向其中放入一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，儿子专等吃盘子中的橘子，女儿专等着吃盘子中的苹果。只有盘子空时，爸爸或妈妈才可向盘子中放一个水果。仅当盘子中有自己需要的水果时，儿子或女儿才可以用盘子中取出水果。
互斥信号量 mutex; empty,full1,full2;

代码示例

semaphore mutex=1;
semaphore empty=1;
semaphore full1=0;
semaphore full2=0;
-----------------------------------------------------
producer1(){
 P(empty);
 P(mutex);
 生产一个橘子
 V(mutex);
 V(full1);
}
-----------------------------------------------------
producer2(){
 P(empty);
 P(mutex);
 生产一个苹果
 V(mutex);
 V(full2);
}
-----------------------------------------------------
consumer1(){
 P(full1);
 P(mutex);
 吃掉一个橘子;
 V(mutex);
 V(empty);
}
-----------------------------------------------------
consumer2(){
 P(full2);
 P(mutex);
 吃掉一个苹果;
 V(mutex);
 V(empty;)
}

结论:即使不这是专门的互斥变量mutex,也不会出现多个进程同时访问盘子的现象。
原因在于：本题中的缓冲区大小为 1，再任何时刻，apple,orange,plate三个同步信号量中最多只有一个是1，所以最多只有一个进程的P操作不会被阻塞，并顺利的进入临界区。
如果缓冲区为2，不设置mutex，就可能导致数据覆盖的问题
所以如果缓冲区大小大于1，就必须设置Mutex进行保护
实现互斥P操作一定要在实现同步P操作之后。

---

抽烟者问题

问题描述

抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。

思路分析

代码实现

读者写者问题

#专业课

问题描述

![[Pasted image 20220503163954.png]]
有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时可能导致数据不一致的错误。因此要求：

1. 允许多个读者进程可以同时对文件执行读操作
2. 只允许一个写着进程往文件中写信息
3. 任一写者在完成写操作之前不允许其他读者或写者工作
4. 写者执行写操作前，应让已有的读者和写者全部退出

问题要点

1. 与消费者进程不同，读者进程在读数据后并不会将数据清空，并不会改变数据。因此多个读者进程可以同时访问共享数据。
2. 读进程与写进程同时共享数据，可能导致读出的数据不一致的问题
3. 两个写进程同时共享数据，可能导致数据错误覆盖的问题

解题步骤

1. 关系分析，找出题目中描述的各个进程，分析他们之间的同步、互斥关系
2. 整理思路，根据各进程的操作流程确定P、V操作的大致顺序。
3. 设置信号量，设置需要的信号量，并根据题目条件确定信号量初值。（互斥信号量初值一般设置为1，同步信号量的初始值要看对应资源的初始值是多少）

问题思考

1. 两类进程:
   1. 写进程
   2. 读进程
2. 互斥关系:
   1. 写进程-写进程
   2. 写进程-读进程
   3. 读进程和读进程之间不存在互斥关系
3. 写者进程和任何进程都互斥，因此要设置一个互斥信号量rw,在写者文件前后分别执行P,V操作，读者进程和写者进程也要互斥，因此读者访问共享文件前后也要对rw进程P,V操作，但是如果所有读者进程在访问共享文件前后都执行P(rw)操作，那么会导致各个进程之间无法同时访问文件，那么应该怎么办？
4. 针对上述的我呢提，我们可以让第一个访问文件的读进程加锁，让最后一个访问文件的读进程解锁，可以设置一个整数变量count来记录当前有几个读进程在访问文件。

代码实现

semaphore rw=1;//用于实现对文件的互斥访问，表示当前是否有进程访问共享文件
int count=0;
semaphore mutex;//用于保证对count变量的互斥访问
semaphore w;//用于实现写优先
--------------------------------------------writer(){
	while(1){
	P(w);
	P(rw);
	写进程
	V(rw);
	V(w);
	}
}
--------------------------------------------
readr(){
	while(1){
	P(w);
	P(mutex);
	if(count==0)
		P(rw); //第一个进程负责枷锁
	V(mutex);
	V(w);
	count++;
		读文件
	count --;//访问文件数-1
	P(mutex);
	if(count==0)
		V(rw);
	}
	V(mutex);
}

可能问题

1. 若两个读进程并发执行，则两个读进程有可能先后执行P(rw),从而使第二个读进程阻塞的情况
   如何解决:出现上述问题的原因在于对count变量的检查和复制无法一气呵成，因此可以设置另一个互斥信号量来保证各读进程对count的访问是互斥的。
2. 只要有读进程还在读，写进程就要一直阻塞等待，可能“饿死”，因此，这种算法中，读进程是优先的。
   1. 读者1->读者2
   2. 读者1->写者2
   3. 写者1->读者1
   4. 读者1->写者1->读者2
   5. 写者1->读者1->写者1
      1. 在这种算法中，连续进入的多个读者可以同时读文件，写者和其他进程不能同时访问文件；写者不会饥饿，但也并不是真正的写优先，而是相对公平的先来先服务原则
      2. 有的书上把这种算法称为"读写公平法"
3. 读者-写者问题为我们解决复杂的互斥问题提供了一个参考思路:其核心思想在于设置了一个计数器count用来记录当前正在访问共享文件的读进程数，我们可以用count的值来判断当前进入的进程是否是第一个/最后一个读进程，从而做出不同的处理。另外，对count变量的检查和赋值不能一气呵成导致了一些错误，如果需要实现一气呵成，自然应该想到互斥信号量。

---

哲学家进餐问题

问题描述

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

问题分析

1. 关系分析：系统中有5个哲学家进程，5位哲学家与左右邻居对其中间筷子的访问是互斥关系
2. 整理思路：这个问题中只有互斥关系，但与之前遇到的问题不同的是，每个哲学家进餐需要同时持有两个临界资源才能开始吃饭。如何避免临界资源分配不当造成的死锁现象，是哲学家们的问题
3. 信号量设置。定义互斥信号量数组chopstick[5]={1,1,1,1,1}用于实现对5个筷子的互斥访问，并对哲学家按0-4编号，哲学家i左边的筷子编号为i,哲学家右边的筷子编号为(i+1)%5

代码分析

semaphore chopsticks[5]={1,1,1,1,1}
Pi(){
	//i号哲学家进程
	while(1){
	P(chopstick[i]);//拿左
	P(chopstick[i+1]%5);//拿右
	进餐
	V(chopstick[i]);//放左
	V(chopstick[(i+1)%]5);//放右
	思考
	}
}

方法3代码

semaphore chopsticks[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);//放右
	思考
	}
}

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

问题分析

1. 如果用最简单的解决方案，是有可能导致死锁的发生的
2. 为了避免死锁的发生
   1. 可以对哲学家进餐施加一些限制条件，比如最多允许四个哲学家同时进餐，这样可以保证至少有一个哲学家是可以拿到左右两只筷子的
   2. 要求奇数号哲学家必须先拿左边的筷子，可以保证两个相邻的奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞，这就避免了占有一支后再等待另一只的情况。
   3. 仅当一个哲学家左右两个筷子都可以使用时候才与许她拿起来筷子。

知识回顾

哲学家进餐问题的关键在于解决进程死锁

1. 这些进程只存在互斥关系，但是与之前的互斥关系不同的是，每个进程都需要同时持有两个临界资源，因此就有了”死锁“问题的隐患。
2. 如果在考试中遇到了一个进程需要同时持有多个临界资源的情况，应该参考哲学家问题的思考，分析题中给出的进程之间是否会发生循环等待，是否会发生死锁等
3. 可以参考哲学家进餐问题的三种思路