【操作系统】处理并发中的常见问题

一、生产者/消费者问题

问题描述：系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用

生产者、消费者共享一个初始为空、大小为n的缓冲区。

只有缓冲区没满时。生产者才能把产品放入缓冲区，否则必须等待。缓冲区没满->生产者生产

只有缓冲区不空时，消费者才能从中取出产品，否则必须等待。缓冲区没空->消费者消费

缓冲区是临界资源，各进程必须互斥地访问。   

从上述分析中，我们找出了该问题的互斥与同步关系：

这也是处理并发问题中的

第一步：找出同步互斥关系

互斥：缓冲区是临界资源，各进程必须互斥地访问

同步：缓冲区没满->生产者生产，缓冲区没空->消费者消费

第二步：根据进程的操作流程确定PV操作的大致顺序

第三步：设置信号量，并根据题目条件确定初值

互斥信号量初值一般为1，同步信号量的初值要看对应资源的初始值是多少

可得代码如下：

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);//增加一个空闲区
      使用产品;
   }
}

 问题：倘若mutex的P操作在前会如何？

即如果代码是这样：

producer(){
   while(1){
      生产一个产品;
      P(mutex);
      P(empty);//消耗一个空闲缓冲区
      把产品放入缓冲区;
      V(mutex);
      V(full);//增加一个产品
   }
}

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

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

则生产者进程执行：mutex变为0->由于没有空闲区，则在P(empty)被阻塞->执行消费者进程,但由于mutex=0，消费者进程也被阻塞，造成死锁现象。

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

V操作的顺序可以交换

二、多生产者/多消费者问题

问题描述：桌子上有一只盘子，每次只能向其中放入一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子转等待吃盘子中的橘子，女儿专等着吃盘子中的苹果。只有盘子空时，爸爸或妈妈才可向盘子中放一个水果。仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出水果。

问题可以简单描述为：多个生产者和多个消费者公用一个缓冲区，但生产者生产不同的产品，消费者消费不同的产品。

第一步：找出同步互斥关系

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

同步关系：

1.父亲将苹果放入盘子后，女儿才能取苹果

2.母亲将橘子放入盘子后，儿子才能取橘子

3.只有盘子为空时，父亲或母亲才能放入水果

第二步：确定PV操作的大致顺序

第三步：设置信号量

互斥关系（mutex=1）

同步关系（orange=0，apple=0，plate=1）；

代码实现：

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

dad(){
   while(1){
       准备一个苹果;
       P(plate);
       P(mutex);
       把苹果放入盘子;
       V(mutex);
       V(apple);
   }
}

mom(){
  while(1){
      准备一个橘子;
      P(plate);
      P(mutex);
      把橘子放入盘子;
      V(mutex);
      V(orange);
  }
}

daughter(){
   while(1){
      P(apple);
      P(mutex);
      从盘中取出苹果;
      V(mutex);
      V(plate);
      吃掉苹果;
   }
}

son(){
   while(1){
      P(orange);
      P(mutex);
      从盘中取出橘子;
      V(mutex);
      V(plate);
      吃掉橘子;
   }
}

实际上在这个问题中不设置互斥变量mutex也可以实现互斥

semaphore apple=0; //盘子中有几个苹果
semaphore orange=0;//盘子中有几个橘子
semaphore plate=1; //盘子中还可以放多少个水果

dad(){
   while(1){
       准备一个苹果;
       P(plate);
       把苹果放入盘子;
       V(apple);
   }
}

mom(){
  while(1){
      准备一个橘子;
      P(plate);
      把橘子放入盘子;
      V(orange);
  }
}

daughter(){
   while(1){
      P(apple);
      从盘中取出苹果;
      V(plate);
      吃掉苹果;
   }
}

son(){
   while(1){
      P(orange);
      从盘中取出橘子;
      V(plate);
      吃掉橘子;
   }
}

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

因此：如果缓冲区大于1，就必须设置互斥信号量mutex来保证互斥地访问缓冲区

三、吸烟者问题

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

第一步：找出同步互斥关系

组合一：纸＋胶水

组合二：烟草＋胶水

组合三：烟草＋纸

桌子可以抽象为容量为1的缓冲区，要互斥访问

同步关系：

桌子上有组合一->第一个抽烟者取走

桌子上有组合二->第二个抽烟者取走

桌子上有组合三->第三个抽烟者取走

发出完成信号->供应者将下一个组合放到桌子上

第二步：确定PV操作顺序

第三步：设置信号量

因缓冲区大小为1，且最多只有一个信号量值为1，故可不设置互斥信号量

代码：

semaphore offer1=0; //桌子上组合一的数量
semaphore offer2=0; //桌子上组合二的数量
semaphore offer3=0; //桌子上组合三的数量
semaphore finish=0; //抽烟是否完成
int i=0;            //用于实验”三个抽烟者轮流抽烟“

provider(){
    while(1){ 
        if(i==0){    
           将组合一放桌上;
           V(offer1);
        } else if(i==1){
           将组合二放桌上;
           V(offer2);
        } else if(i==2){
           将组合三放桌上;
           V(offer3);
        }
        i=(i+1)%3;
        P(finish);
     }
}

smoker1(){
   while(1){
      P(offer1);
      从桌子上拿走组合一，抽掉;
      V(finish);
   }
}

smoker2(){
   while(1){
      P(offer2);
      从桌子上拿走组合二，抽掉;
      V(finish);
   }
}

smoker3(){
   while(1){
      P(offer3);
      从桌子上拿走组合三，抽掉;
      V(finish);
   }
}

四、读者/写者问题

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

1.允许多个读者可以同时对文件执行读操作；

2.只允许一个写者往文件中写信息

3.任一写者在完成写操作之前不允许其他读者或写者工作

4.写者执行写操作前，应让已有的读者和写者全部退出

第一步：分析同步、互斥关系

互斥关系：写进程/写进程、写进程/读进程

第二步：确定PV操作顺序

第三步：设置信号量

这里介绍一种读者优先的代码：

semaphore rw=1;   //用于实现对共享文件的互斥访问
int count=0;      //记录当前有几个读进程在访问文件
semaphore mutex=1;//用于保证对count变量的互斥访问
writer(){
   while(1){
      P(rw); //写之前”加锁“
      写文件;
      V(rw); //写完了”解锁“
   }
}

reader(){
   while(1){
       P(mutex);//各读进程互斥访问count
       if(count==0)//由第一个读进程负责加锁，从而实现多个读进程同时访问
           P(rw);
       count++; //访问文件的读进程数+1
       V(mutex);
       读文件
       P(mutex);//各进程互斥访问count
       count--;//访问文件的读进程书-1
       if(count==0)//由最后一个读进程负责解锁
           V(rw);
       V(mutex);
   }
}

上述代码存在问题，倘若读进程一直读，那么写进程可能会被”饿死“

写者优先代码如下：

semaphore rw=1;   //用于实现对共享文件的互斥访问
int count=0;      //记录当前有几个读进程在访问文件
semaphore mutex=1;//用于保证对count变量的互斥访问
seaaphore w=1;    //用于实现写优先
writer(){
   while(1){
      P(w);
      P(rw); //写之前”加锁“
      写文件;
      V(rw); //写完了”解锁“
      V(w);
   }
}

reader(){
   while(1){
       P(w);
       P(mutex);//各读进程互斥访问count
       if(count==0)//由第一个读进程负责加锁，从而实现多个读进程同时访问
           P(rw);
       count++; //访问文件的读进程数+1
       V(mutex);
       V(w);
       读文件
       P(mutex);//各进程互斥访问count
       count--;//访问文件的读进程书-1
       if(count==0)//由最后一个读进程负责解锁
           V(rw);
       V(mutex);
   }
}

五、哲学家就餐问题

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

即如上图所示。

 第一步：关系分析，系统中有5个哲学家进程，5位哲学家与左右邻居对其中间筷子的访问是互斥关系。

第二步：这个问题中只有互斥关系。但与之前遇到的问题不同的是，每个哲学家进程需要同时持有两个临界资源才能开始吃饭。如果避免临界资源分配不当造成的死锁现象，是哲学家问题的精髓。

第三步：信号量设置。定义互斥信号量数组chopstick[5]={1，1，1，1，1}用于实现对5个筷子的互斥访问。并对哲学家按0—4编号，哲学i左边的筷子为i，右边的筷子为（i+1）%5

semaphore chopstick[5]={1,1,1,1,1};
Pi(){
   while(1){
       P(chopstick[i]);
       P(chopstick[(i+1)%5];
       吃饭
       V(chopstick[i]);
       V(chopstick[(i+1)%5];
       思考
   }
}

上述代码中，5位哲学家并发地拿起了自己左手边的筷子，则每位哲学家都等待其他哲学家放下自己右边的筷子，从而造成死锁。

如何避免死锁的发生，可以对该问题做一些限制，比如：

1.最多允许四个哲学家同时进餐，这样可以保证至少有一个哲学家是可以拿到左右两只筷子的

2.要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数好哲学家则相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一支筷子，另一个会直接阻塞，从而避免了占有一只再等待另一只的情况。

3.仅当一个哲学家左右两只筷子都可用时，采用允许他抓起筷子

情况三代码如下：

semaphore chopstick[5]={1,1,1,1,1};
semaphore mutex=1;
Pi(){
   while(1){
       P(mutex);
       P(chopstick[i]);
       P(chopstick[(i+1)%5];
       V(mutex);
       吃饭
       V(chopstick[i]);
       V(chopstick[(i+1)%5];
       思考
   }
}