操作系统第二章进程管理

写在前面：本文参考王道论坛的操作系统考研复习指导单科书

文章目录

第二章进程管理
- 进程同步
- - 读者写者问题
  - 哲学家就餐问题
- 练习题
- - 哲学家就餐：加碗（2019真题）
  - 既是生产者又是消费者
  - 和尚取水（生产者-消费者问题）
  - 三个合作进程（同步：前驱图）
- 死锁
- - 死锁预防
  - 死锁避免（银行家算法）
  - 死锁检测与解除

第二章进程管理

进程同步

信号量用于实现进程间的同步和互斥访问。

读者写者问题

模型：读写之间互斥，写写之间互斥；读读不互斥。

关键特征：互斥访问的计数器count。

1）关系分析

写者和任何人都是互斥的，读者和读者不存在互斥关系。

2）思路整理

共有两个进程，读者reader()和写者writer().

写者：因为和任何进程互斥，只要P、V操作即可。
读者：互斥信号量rw实现读写互斥；为了实现读者间同时访问，创建变量count，用于统计正在读共享文件的读者数量。只有第一个读者可以P(rw);只有最后一个读者可以V(rw); 使用互斥信号量mutex用于不同读者进程互斥的访问count变量.
写优先
- 设置互斥信号量w用于控制写优先。读进程和写进程在进入后首先P(w)，表示在无写进程的时候进入，实现写进程优先。

使用信号量实现进程的互斥和同步：

#include<stdio.h>/* typedef struct{int value;struct process *L;
}semaphore;*/
#define semaphore intsemaphore rw = 1; // 读者和写者互斥访问
int count = 0; // 统计正在读共享文件的读者数量
semaphore mutex = 1; // 多个读进程互斥的访问count变量
semaphore w = 1; // 用于实现写优先void writer(){while (1){P(w); // 在无写请求的时候进入P(rw); //互斥访问共享文件// writingR(rw);V(w); //恢复对共享文件的访问}}void reader_write_first(){while(1){P(w); // 在没有写请求的时候进入P(mutex);if(count == 0)P(rw);count ++;V(mutex);V(w); // 恢复对共享文件的访问// readingP(mutex);count --;if(count == 0)V(rw);V(mutex);}
}

哲学家就餐问题

哲学家问题的一种解法

思路一：至多允许n-1个哲学家同时就餐


semaphore Max = n - 1;  // 最多允许n -1 个人同时吃饭
semaphore chopsticks[n];for(int i = 0; i < n; i ++)chopsticks[i] = 1;Pi(){P(Max);P(chopsticks[i]); // 拿左手边的筷子P(chopsticks[(i+1)%n]); // 拿右手边的筷子//eatingV(Max);V(chopsticks[i]);V(chopsticks[(i+1)%n]);// thinking
}

练习题

哲学家就餐：加碗（2019真题）

思路：使用互斥信号量来控制哲学家拿筷子。取互斥信号量bowl取筷子(n)和碗(m)两者的最小值。why？

当m < n时，碗的数量少，此时P(bowl) 和V(bowl)可以起到限制作用。此时，碗的数量m相当于普通的哲学家问题解法里面的Max，即Max = m;
当n ≥ m时，碗多，此时P(bowl) 和V(bowl)不起作用。问题退化为普通的哲学家就餐问题，此时Max = n - 1;

综上，取semaphore bowl = min(m, n- 1);

信号量伪代码：

#include<stdio.h>/* typedef struct{int value;struct process *L;
}semaphore;*/
#define semaphore int
#define n 3
#define m 5semaphore chopsticks[n];
semaphore bowl = min(n - 1,m);void Pi(){for(int i = 0; i < n; i ++)chopsticks[i] = 1; // 互斥信号量全部初始化为1P(bowl);P(chopsticks[i]);P(chopsticks[(i+1)%n]);// eatingV(chopsticks[i]);V(chopsticks[(i+1)%n]);V(bowl);// thinking
}

既是生产者又是消费者

解答

#include<stdio.h>/* typedef struct{int value;struct process *L;
}semaphore;*/
#define semaphore int
semaphore mutex = 1;// 互斥访问缓冲区
semaphore full = 0; // 缓冲区产品的数量
semaphore empty  = 1; // 缓冲区空格的数量//P是生产者
void P(){while(1){P(empty);P(mutex);// produce oneV(mutex);V(full);}
}// Q是消费者
void Q(){while(1){P(full);P(mutex);// consume oneQ(mutex);Q(empty);}
}//R 既是生产者又是消费者
void R(){// 执行producer的职能if(empty == 1){P(empty);P(mutex);// produce one;V(mutex);V(full);}//执行consumer的职能if(full == 1){P(full);P(mutex);// consume oneV(mutex);V(empty);}
}

和尚取水（生产者-消费者问题）

信号量代码

#include<stdio.h>/* typedef struct{int value;struct process *L;
}semaphore;*/
#define semaphore intsemaphore well = 1; //用于互斥访问水井
semaphore vat = 1; // 用于互斥访问水缸
semaphore empty = 10; // 表示水缸内还可以容纳的水的桶数
semaphore full = 0; // 表示水缸中水的桶数
semaphore pail = 3; // 表示有多少个水桶可以用void old_monk(){P(full); // 老和尚取水后，水缸中水的数量--P(pail);P(vat);// 从水缸(vat)中取一桶水V(vat);V(empty); // 取完水后，水缸剩余空间++// 喝水V(pail); }
/*
注意P操作的先后顺序:先确认水缸还有空余位置，再去拿桶，再打水。*/void little_monk(){P(empty); // 水缸中剩余空间-- P(pail);P(well);// 从水井（well）中打一桶水V(well);P(vat);// 倒入水缸(vat)V(vat);V(full); // 水缸中水量++v(pail);
}

本题批注：

连续多个P操作连在一起的时候，检查可能会发生死锁。本题如果先P(pail)，再P(empty)；就会发生死锁。pail是水桶，empty是水缸内剩余空间能容纳的水的桶数

三个合作进程（同步：前驱图）

分析：

各个进程的任务：

P1进程从输入设备输入数据a；然后计算 x = a + b; 使用打印机打印x,y,z;
P2进程从输入设备输入数据b；然后计算y = a * b;
P3进程从输入设备输入数据c；然后计算z = y + c - a;

进程同步：

注意：进程同步前V后P的使用，亦即在前的进程执行完后V(某信号量);，而在后的进程执行前P(某信号量);

下面是三个进程的执行顺序，故而需要两个同步信号量。

$P_1 /rightarrow P_2 /rightarrow P_3$

此题有前驱图的感觉。前驱图使用信号量进行同步，所以就不需要再使用另外的互斥信号量mutex了。

死锁

死锁v.s. 饥饿 v.s. 死循环

死锁：各进程相互等待对方手里的资源，导致各进程都阻塞
饥饿：某进程长时间得不到某种资源，无法向前推进。比如短进程优先(SPF)算法中，长进程可能一直无法运行，“饥饿”
死循环：某进程执行过程中一直跳不出某个循环的现象

死锁和饥饿是操作系统要解决的问题，死循环是应用程序员要解决的问题。

死锁预防

死锁避免（银行家算法）

死锁检测与解除

系统为进程分配资源时不采取任何措施，而在具体分配过程中提供死锁检测和解除的手段。

资源分配图：是一个有向图，用于表示某时刻系统资源与进程之间的关系。

圆圈代表进程，方框代表一类资源，方框内圆圈个数代表该类资源的个数。

死锁的知识结构