【操作系统】复习荟萃（二）

第二章——进程的描述与控制

题目

试举例说明并发进程访问临界资源，在没有互斥条件下所产生的不可再现性
生产者-消费者：

前趋图

描述程序执行先后顺序，结点表示进程或程序段$P_i\to P_j$
表示$P_i{P}_j$存在前趋关系，$P_i$要在$P_j$开始之前完成

顺序执行

特征：
顺序性：处理机严格按照所规定顺序执行
封闭性：程序在封闭环境下运行，运行时独占全机资源
可再现性：保持环境和初始条件，重复执行结果相同

并发执行

顺序执行系统资源利用率低，要引入多道程序技术，只有不存在前趋关系的程序之间才会并发执行

特征：
间断性：相互制约导致“执行—暂停—执行”
失去封闭性：各类资源共享，环境也受到影响
不可在现行性：因为失去了封闭性，计算结果与并发程序的执行速度有关，失去可再现性
条件：
读、写集
$R(p_i)=(a_1,a_2,....a_m)$表示程序$p_i$在执行期间所要参考的变量的集合，写集为要改变
Bernstein条件：
$$R(p_1)\cap W(p_2)\cup R(p_2)\cap W(p_1)\cup W(p_1)\cap W(p_2)=\varnothing$$
满足就可以并发执行，且具有可现性

S 1 : a : = x + y   S 2 : b : = z + 1 S 3 : c : = a − b   S 4 : w : = c + 1 R ( S 1 ) = { x , y } R ( S 2 ) = { z } R ( S 3 ) = { a , b } R ( S 4 ) = { c } S_1:a:=x+y\ S_2:b:=z+1\\S_3:c:=a-b\ S_4:w:=c+1\\R(S_1)=\{x,y\}\\R(S_2)=\{z\}\\R(S_3)=\{a,b\}\\R(S_4)=\{c\} S1​:a:=x+y S2​:b:=z+1S3​:c:=a−b S4​:w:=c+1R(S1​)={x,y}R(S2​)={z}R(S3​)={a,b}R(S4​)={c}
W ( S 1 ) = { a } W ( S 2 ) = { b } W ( S 3 ) = { c } W ( S 4 ) = { w } W(S_1)=\{a\}\\W(S_2)=\{b\}\\W(S_3)=\{c\}\\W(S_4)=\{w\} W(S1​)={a}W(S2​)={b}W(S3​)={c}W(S4​)={w}
开始判断$S_1{S}_2$：
$R_1\cap W_2=\varnothing$
$R_2\cap W_1=\varnothing$
$W_1\cap W_2=\varnothing$
可以并发~

进程

进程基础知识

定义：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位
进程与程序：
（1）进程是程序的一次执行
（2）进程是暂时的，程序是永恒的
（3）一段进程可以包含几段程序，一段程序可以对应多个进程
进程实体：PCB，程序段，数据段
PCB：进程控制块——使参与并发程序的每个数据都能独立地运行，在操作系统中给它配置的一个专门的数据结构，进程存在的唯一标志
PCB的信息

1. 进程标识符：标识一个进程
2. 处理机状态：处理机的各种寄存器——通用寄存器、指令计数器、程序状态字PSW、用户栈指针
3. 进程调度信息：进程状态、进程优先级、进程调度所需的其他信息、事件（阻塞原因）
4. 进程控制信息：程序和数据的地址、进程同步和通信机制、资源清单、链接指针
   组织形式：
   链接方式：按进程状态将PCB分为多个队列
   索引方式：按照进程状态建立索引表
   特征：
   动态性（有一定生命期）、并发性、独立性（独立资源，接受cpu调度）、异步性（进程运行速度不会停停走走）

进程状态转换

三态转换：
就绪—进程调度—>执行——I/O请求（主动行为）—>阻塞—I/O完成—>就绪
执行—时间片用完—>就绪
执行——>终止

执行状态：已经获得CPU,单处理机只有一个进程处于执行状态，多处理机多个
就绪状态：已准备好运行，只要获得CPU就可以执行，就绪队列
阻塞状态：正在执行的进程由于发生某事件（I/O），暂时无法继续执行
创建状态：进程所需的资源尚不能得到满足
终止状态：不再执行，保留记录

进程控制

创建新进程、终止已完成的进程、置于阻塞、状态转换等等
处理机的执行状态：
系统态（管态）：较高特权
用户态（目态）：较低特权
应用程序只在用户态执行
如何实现进程控制？
原语：若干条命令组成，用于完成一定功能的一个过程，称为原子操作，不可分割，在系统状态下执行。
原语执行期间不允许中断，采用“关中断指令”和“开中断指令”（特权指令）

进程的创建

引起进程创建的事件：
用户登录、作业调度（从外存进内存）、提供服务（用户请求打印）、应用请求
进程创建过程：
申请空白PCB
为新进程分配所需资源（物理+逻辑）
初始化PCB
加入就绪队列

进程的终止

引起进程终止的事件：
正常结束、异常结束（越界、非法访问、非法指令、特权指令、运行超时、超时等待、算数运算、IO故障）、外界干预（ctrl+c）
进程终止的过程：
根据终止进程的标识符，从PCB集合中检索出该进程的PCB，读出状态
终止执行，置调度标志真
子孙进程终止
移除PCB队列

进程的阻塞，唤醒，挂起，激活

引起阻塞和唤醒的事件：
向系统请求共享资源失败、等待操作完成（IO）、新数据未到达（wait）、等待新任务到达（网络进程）
进程阻塞过程：
进程使用阻塞原语block将自己阻塞
停止运行并进入阻塞队列，调度程序重新调度
进程唤醒过程：由有关进程使用wakeup原语唤醒
将进程从阻塞队列移出，将PCB改为就绪，加入就绪队列。
进程挂起过程：用户或父进程提出，OS利用suspend挂起指定进程
检查进程状态，改为对应的静止状态，复制PCB到指定内存区域以备查看。指引重新调度
进程激活过程：OS利用active激活制定进程
将进程从外存调入内存，检查状态，改为对应就绪/阻塞状态。如果有抢占机制比较是否抢占

进程同步

对多个相关进程进行协调，使并发执行的进程之间按照一定的规则(或时序)共享系统资源，并可以相互合作，执行具有可再现性
两种制约关系：
（1）间接制约关系
由于共享资源，如CPU，I/O，形成了源于对该类资源共享的间接制约关系
（2）直接相互制约关系
为完成同一项任务相互合作，比如写进程和读进程
临界资源
一个时间段内只允许一个进程使用。
对临界资源的互斥访问四个部分：

do{
进入区   //检查是否进入临界区，可以的话进入，并设置上锁
临界区  访问临界资源的代码
退出区  //解除标志
剩余区 //其他
}while(true)

原则：
空闲让进，忙则等待，有限等待，让权等待

硬件同步机制

关中断：实现互斥，直接让这个进程不中断，也就没有其他进程访问临界资源（一个cpu）
缺点：
滥用关中断权力严重后果；
关中断时间过长，影响效率；
不适用多cpu
TS（原语）：不可中断
lock：临界区共享变量，false空闲

boolean TS(boolean *lock)
{
	boolean old;
	old=*lock;
	*lock=TRUE; //无论上锁否，现在都上锁
	return old;
}

do{
...
while TS(&lock);  //TRUE则一直循环，FALSE跳出循环（空闲），进入临界区
临界区
lock=FALSE;  //解除
剩余部分
}while(TRUE)

有题：
改变TS原语

while(TS(x)=TRUE)则空闲，FALSE则忙碌
S=TS(x)
x=FALSE;
while(S==FALSE);

F为忙碌
T为空闲

S=T
while(TS(S)!=T);
S=T;

Swap：对换指令
每个临界资源设置一个全局布尔变量lock，初值是false——让进，局部布尔变量key

void swap(boolean *a, boolean *b)
{
	boolean temp;
	temp=*a;
	*a=*b;
	*b=temp;
}

do{
	key=TRUE;
	do{
	swap(&lock,&key);
	}while(key==TRUE);
	临界区
	lock=FALSE
	...
}while(TRUE)

信号量机制

因为硬件都没有实现让权等待，信号量机制诞生了
信号量，就是一个变量，可用来表示系统中某种资源的数量
申请：P(S)=wait()
释放：V(S)=signal()
就是最开始-1
整型信号量
表示系统中某种资源的数量，不满足让权等待，会忙等
记录型信号量
S.value的初值表示资源的数目
都是先加减，再判断value
P操作——请求——（-1）之后发现<0了，就把自己阻塞，队列挂起
V操作——释放——（+1）之后发现<=0，说明还有进程在等待资源（这时候还没给呢），就唤醒队列的第一个进程
进程互斥：

semaphore m=1；
P1(){
...
P(m);
临界区···
V(m);
...
}
P2(){
...
P(m);
临界区···
V(m);
...
}
<0就挂起

进程同步：
前操作之后执行V，后操作之前执行P

semaphore m=0；<0就挂起

例子：

P1中有代码S1，每一对前驱关系设置一个同步变量

P1(){ 
S1;
V(a);
V(b);
}
P2(){ 
P(a);
S2;
...
}

生产者-消费者
生产者每次生产一个放入缓冲区，消费者消费一个
缓冲区大小=n
两个同步，一个互斥(初值为1)

semaphore m=1; //互斥信号量
semaphore empty=n; //同步信号量
semaphore full=0;  //同步信号量

生产者:
{
P(empty);
P(m);
生产产品
V(m);
V(full);
}while(true)

消费者：
{
P(full);    //分别在两个函数里代表同步（规定顺序）
P(m);     //一个函数里表示互斥，临界资源，两个V可交换
取出产品
V(m);
V(empty);
}while(true)

几个同步就几个同步信号量，前趋关系参照前驱图，同步初值就是资源当前初值

多生产者-多消费者
一个盘子，甲放苹果，丙吃苹果，乙放梨子，丁吃梨子
（1）几个进程：4个
（2）几个缓冲区：1个——互斥
（3）一前一后同步关系：3个——甲：丙；乙：丁；空：甲、乙
所以，3个同步信号量，1个互斥信号量（初值为1）

semaphore m=1; //互斥信号量
semaphore apple=0; //同步信号量
semaphore pear=0;  //同步信号量
semaphore empty=1;  //同步信号量
甲:
do{
准备水果
P(empty);
P(m);
放apple
V(m);
V(apple);
}while(true)

乙：
do{
准备水果
P(empty);   
P(m);     
放pear
V(m);
V(pear);
吃掉
}while(true)

丙：
do{
P(apple);   
P(m);     
吃apple
V(m);
V(empty);
吃掉
}while(true)

丁：
do{
P(pear);   
P(m);     
放pear
V(m);
V(empty);
}while(true)

单生产者，多消费者循环就 int i=0，然后if if
读者写者问题
多个读者同时访问没事，一个写者在写，其他都不可以干，写之前让所有读者和写者退出
（1）进程：写，读
（2）互斥：写—写，写—读
这道题的关键是读之前会加索，第二个读也会加锁，但是读读不冲突，引入count变量记录读者个数
R互斥变量对count进行互斥，使count==0与count++一气呵成

semaphore rw=1 //文件互斥访问
int count=0  //记录当前读进程
semaphore mutex=1  //count变量互斥访问
#semaphore w=1  //实现写优先  
do{
    #P(w);
	P(mutex);  //对count进行互斥，使count==0与count++一气呵成
	if(count==0) 
	  P(rw)   //判断是否为第一个
	count++;
	V(mutex);
	#V(w);
	读
	P(mutex); 
	count--;
	if(count==0)  
	  V(rw);
	V(mutex);
}while(TRUE);

写者：

do{
	#P(w);
	P(rw);
	写操作
	V(rw);
	#V(w);
}while(TRUE);

存在源源不断的读，写进程不会唤醒的问题
哲学家进餐（两个临界资源）
五个哲学家，思考or吃饭，每人一只筷子，拿左边和右边两只筷子，才可以吃饭
设筷子数组：chopstick[5]={1,1,1,1,1}
第i个哲学家左边筷子chopstick[i]，右边筷子chopstick[(i+1)%5]
（1）只限制4个人进餐，都拿左边筷子
（2）设奇数号拿左边，偶数拿右边
（3）左右两边都可以使用的时候拿起筷子

semaphore chopstick[5]={1,1,1,1,1}
semaphore mutex=1; //互斥地取筷子
do{              
	P(mutex);
	P(chopstick[i]);
	P(chopstick[i+1]%5);
	V(mutex);
	吃饭
	V(chopstick[i]);
	V(chopstick[i+1]%5);
}while(TRUE);

应该还差安and型

管程

信号量编写程序困难，易出错
高级的同步机制
管程的组成：（类）
(1)局部于管程的共享数据结构说明；（临界资源）
(2)对该数据结构进行操作的一组过程（处理函数）
(3)对局限于管程的共享数据设置初始值的语句（初始化语句）
(4)管程的名称
管程基本特征
数据只能被局限于管程的过程访问
进程只有调用管程内的过程才能进入管程访问共享数据
仅允许一个进程在管程内执行某个内部过程， 一个进程访问管程，其他进程都要阻塞在外面

进程通信

进程之间的信息交换
一个进程不允许访问其他进程的地址空间
共享存储：操作系统分配两个进程共享空间，互斥访问
基于数据结构：固定的数据格式（低级通信）
基于存储区：共享存储空间，结构自定（高级通信）
管道通信：内存中的缓冲区，半双工（单向传输），全双工要两个管道，互斥访问，写满才读，读完才写
读进程最多一个
消息传递：格式化消息传递，原语实现
直接通信：直接挂在目标进程消息缓冲队列
间接通信：信箱通信，发送到中间实体

线程

线程是处理机调度的单位，进程是资源分配的单位
增加并发度，同一个进程中有多个线程
线程是程序执行流的最小单位，各线程之间可以并发，除CPU以外的系统资源的分配单位，线程是调度的基本单位
线程间并发不用切换进程环境，减小开销
多cpu，各个线程可占用不同的cpu
TCB——线程控制块
几乎不拥有系统资源
同一进程中不同线程，共享使用资源，
同一进程的线程切换不用进程切换，不同要
线程的实现方式
用户级线程：由应用程序通过线程库实现，所有线程管理工作都由应用程序负责，用户态下可完成
内核级线程：线程管理由操作系统内核完成，在核心态完成
组合：
n—m
内核级线程是处理机分配的单位，一个内核级分一个cpu
多线程模型：
多对一：多个用户级线程对应一个内核级线程
优点：不需核心态，开销小，效率高
缺点：一个用户级线程阻塞后，其他都阻塞了
一对一：
优点：阻塞其他不影响，多核并行处理
缺点：开销大
多对多：
n>=m
优点：以上缺点