操作系统知识总结

内容来自考研复习指导书

第2章节：进程管理

2.1进程与线程

1.进程与程序：一个静态程序当运行后，进入OS的内存中了，就成为了进程；
为描述并发执行的进程可以独立运行，用数据结构：PCB来描述，进而可以通过操控他来控制和管理进程；
创建/撤销进程==创建/撤销PCB；
2.进程特征：是动态（所以出现状态转化，类比于线程的状态），并发，独立，异步，
它是系统进行资源分配和调度的一个独立单位；
3.进程状态与转化：
图：创建–>就绪-（阻塞）->运行–>终止
4.进程控制：
1）进程创建：
2）进程终止：
3）进程阻塞与唤醒：（成对出现）
4）进程切换：（进程运行的环境发生实质变化）；
5.进程基本都是OS的调用而进入内核，再OS内核支持下完成运行；
6.调度：将资源决定分配给哪个进程，
切换：实际分配的行为，实际切换进来的是谁；
7.PCB关注信息：
进程描述信息：PID进程标识符，UID用户标识符；
进程控制和管理信息：进程当前状态，优先级；代码运行入口地址，
程序的外存地址，进入内存时间，处理机占用时间，信号量使用；
资源分配清单：
处理机相关信息：
8.将PCB组织起来便于进程的管理和调度的方式：链接方式、索引方式；
链接方式（队列数组）：同状态的PCB为一个队列，不同状态为不同的队列；
索引方式：（hash表）同状态的PCB放进同一个索引表，不同状态对应不同的索引表；
9.程序段===（线程），因为可以多个进程共享他；

10.进程通信

10.1.共享存储：需要用到PV操作和共享存储空间（也就是临界资源）
10.2.消息传递（理解为写信）：直接通信方式：（我<–>你）
间接通信方式：（我<—信箱—->你）应用在计网中的电子邮件系统
10.3管道通信：管道===共享文件：例子是读写进程操作，写进共享文件，读出共享文件；
linux系统最常用这种通信机制，管道是半双工通信，某一时刻，只可以单向传输，要实现双方互动，需要2个管道；

11.多线程

1.线程没有系统资源，他们共享进程的资源，（理解为平时写的代码块程序）；
2.线程是独立调度的基本单位，而进程是拥有资源的基本单位；
3.线程的并发性
4.进程通信需要10所述，而线程通信直接读/写进程的数据段来通信；
5.不同的线程可以执行相同的程序：很多人打开同一个APP，就有很多线程出来执行这个APP；
6.线程是处理机的独立调度单位；
7.线程实现方式：用户级线程（就是自己写代码实现：由main主线程–》多个子线程）；
内核级线程（OS实现）；
8.多线程模型：这里指的是用户（m个）+内核（n个）的模型；

2.2处理机调度

1.概念

1.1调度层次：
1）作业调度：从辅存中—–>内存
2）中级调度：把暂时不运行的进程调至外存等待，挂起状态，等重新调入内存，变为就绪状态，挂在就绪队列上等待；
3）进程调度：按某种算法，从就绪队列中选个将处理机分配给他；

2.进程调度的方式：剥夺和非剥夺

3.调度的基本准则：

1.CPU利用率：忙
2.系统吞吐量：=单位时间内CPU完成作业的数量
3.周转时间：从作业提交到完成所经历的时间；
几个计算概念：
周转时间=1个作业完成时间-1个作业提交时间
平均周转时间=（作业1的周转时间+..+作业n的周转时间）/n
带权周转时间=1个作业周转时间/1个作业实际运行时间
平均带权周转时间=（作业1的带权周转时间+..+作业n的带权周转时间）/n
4.等待时间
5.响应时间（从用户角度而言）

4.典型调度算法

1.先来先服务算法 FCFS
解释：根据到达后备队列的时间来顺序执行
eg.

作业号 提交时间 运行时间 开始时间 等待时间 完成时间 周转时间 带权周转时间 1 8 2 8 0 10 2 1 2 8.4 1 10 1.6 11 2.6 2.6 3 8.8 0.5 11 2.2 11.5 2.7 5.4 4 9 0.2 11.5 2.5 11.7 2.7 13.5

特点：简单，效率低；对长作业有利，对短的不利；不适合用于分时和实时系统,常被结合在其他调度策略中使用:例如优先级算法中对于优先级相同的采用FCFS算法
平均等待时间：t=(0+1.6+2.2+2.5)/4=1.575
平均周转时间：T=（2+2.6+2.7+2.7）/4=2.5
平均带权周转时间：W=（1+2.6+5.4+13.5）/4=5.625
2.短作业优先算法 SJF
解释：从后备队列中挑选最短的先执行
eg.

作业号 提交时间 运行时间 开始时间 等待时间 完成时间 周转时间 带权周转时间 1 8 2 8 0 10 2 1 2 8.4 1 10.7 2.3 11.7 3.3 3.3 3 8.8 0.5 10.2 1.4 10.7 1.9 3.8 4 9 0.2 10 1 10.2 1.2 6

平均等待时间：t=(0+2.3+1.4+1)/4=1.175
平均周转时间：T=（2+3.3+1.9+2.2）/4=2.1
平均带权周转时间：W=（1+3.3+3.8+6）/4=3.525
特点：对于长作业不利，如果后面不断来短的话甚至可能出现“机饿”现象；
3.优先级调度算法
描述：从后备中挑选一个优先级最高的给处理机；
3.1根据新的更高优先级进程是否抢占正在执行的进程又分为：
非剥夺优先级
剥夺优先级
3.2根据进程创建后优先级是否可变，分为：
静态优先级
动态优先级
4.高响应比优先调度
描述：用于作业调度，先计算每个后备作业的响应比，跳最高的作业；
响应比= 等待时间+要求服务时间/要求服务时间
总结：
4.1）当等待时间相同时，则服务时间越短，响应比越高，利于短作业；（SJF算法）
4.2）当服务时间相同时，则等待时间越长，响应比越高，（那些先到的也就是在这里等待的时间越长的）所以实现的是FCFS算法；
4.3对于长作业也就克服机饿现象发生；
5.时间片轮转算法
描述：用于分时系统，按照FCFS算法执行每个进程，但是每个进程只能运行1个时间片，如果没运行完成，就被剥夺放在队尾；
关键是1个时间片大小选择：大了==FCFS，小了==频繁切换，处理机开销增大；
6.多级反馈队列调度算法
描述：时间片轮转+优先级；
first ： 设置多个就绪队列，设置不同优先级，1》2》3….》n
second：设置各个队列中进程执行的时间片大小不同：1《2《3….《n
third:1个新进程近来放在第1级队列末尾，按照FCFS算法执行，如果未执行完，就放在第2队列，依次下放，放在第N队列就采用时间片轮转，不再下放；
fourth：仅当第1队列为空，才执行第2队列，剩下同理到N，
如果出现正在执行第i级队列的某个进程，但进来个优先级更高的进程放在较高队列，此时处理机就把正在执行的进程放在此对列的尾部，然后把自己分配给新进程来执行；
优点：短作业优先，周转时间短，经过前面几个队列得到部分执行，不会长期得不到处理，也就是机饿现象不会有；

2.3进程同步

1.同步概念

1.进程并发执行，不同进程相互制约，协调这种关系，引入进程同步：
eg。1+2*3
出现加法进程和乘法进程，由于OS的异步性可能导致进程执行顺序不同，所以要协调进程执行机制；
2.临界资源：一次仅允许一个进程使用的资源；
比如：打印机、数据、变量；
对于临界区访问，要互斥进行：
do{
entry section; //进入区
critical section;//临界区
exit section; //退出区
remainder section;//剩余区
}
3.同步：
也称为直接制约关系，2个以上的进程需要协调工作次序而等待、传递信息而产生的制约关系；
eg。进程A通过单缓冲向进程B提供数据，
缓冲区为空：B阻塞，一旦A放入数据，B唤醒；
缓冲区为满：A阻塞，一旦B取走数据，A唤醒；
4.互斥（与临界资源相关）
也称间接制约关系，2个以上进程，当A进程进入临界资源使用时，B进程必须等待，
当A使用完毕后，B才可以使用；

2.实现临界区互斥的基本方法

1.软件代码方法：
Peterson’s Algorithm(彼得森算法)
Pi进程： Pj 进程：
flag【i】 = TURE; turn = j; flag[j] = TURE; turn = i; //进入区
while(flag[j] && turn == j ) while(flag[i] && turn == i)
; ;
critical section; critical section; //临界区
flag[i] = FLASE; flag[j] = FLASE; //退出区
remainder section; remainder section; //剩余区
分析：考虑进程Pi，一旦他想进入，则满足flag【i】 = TURE; turn = j;
如果Pj已在临界区，则符合while条件，Pi就不能进入；
如果Pj不在临界区，即flag【j】=flase;则不符合while条件中的flag[j]，Pi就能进入；
进程Pj同理；
算法核心:用flag解决临界资源互斥访问，利用turn解决饥饿现象（这里指当2个进程同时要求进入临界区）；
2.硬件方法
不写了。。。。

3.信号量

1.记录型信号量（链表结构）
1.1)定义记录数据结构
typedef struct{
int value;
struct process *L;
}semaphore;
1.2)wait(S)
void wait(semaphore S){
S.value –; //进程申请一个资源
if(S.value < 0){ //资源分配完毕，则阻塞进入队列等待
add this process to S.L;
block(S.L);
}
}
1.3） signal（S） //释放资源
void signal(semaphore S){
S. value++;
if(S. value <=0){ //表示S.L中仍有等待该资源的进程被阻塞，继续调用wakeup唤醒
remove a process P from S.L;
wakeup(P);
}
}
2.利用信号量实现同步
描述：S为实现进程P1、P2同步的公共信号量，初始化为0.
P2中的y需要使用P1中的x，只有先x而后才y；
算法：
semaphore S = 0;
P1 () {
x;
V(S); //告诉P2，语句x完成
}
P2(){
P(S); //检查x是否完成
y; //检查无误，才运行y语句
}
3.利用信号量实现进程互斥
设S为实现进程P1、P2互斥的信号量，
由于每次只允许1个进程进入临界区，所以S = 1（可用资源为1），把临界区置于P(S)和V(S)
之间，就可以实现互斥访问。
semaphore S = 1 ;
P1(){
P(S); //S–,加锁
进程P1临界区；
V(S); //S++;解锁
}
P2(){
P(S); //S–,加锁
进程P2临界区；
V(S); //S++;解锁
}
4.分析同步和互斥问题的方法步骤
1）确定进程：找出问题的进程数，并且分析之间的同步和互斥关系，仿写上面例子；
2）逻辑P\V操作顺序：根据问题流程确定P操作、V操作顺序；
3）设置信号量：设置初始值；

4.经典同步问题

1.生产者-消费者问题（互斥+同步）
问题描述：
生产者+消费者进程 共享一个初始为空，大小为n的缓冲区；
只有缓冲区没满时，生产者才能把消息放入缓冲区，否则等待；
只有缓冲区不空时，消费者才能从缓冲区取出消息，否则等待；
由于缓冲区为临界资源，只允许一个生产者放入消息，或者一个消费者取出消息。
分析：
确定进程：2个；生产者+消费者
分析关系：互斥缓冲区+同步进程
设置信号量：互斥信号量：mutex=1；
full：记录缓冲池中的”满“缓冲区数，full=0；
empty：记录缓冲池中的”空“缓冲区数，empty=n；
答案：
semaphore mutex = 1;
semaphore empty = n;
semaphore full = 0;
producer(){
while(1){
produce an item in nextp; //生产数据
P(empty); //获取空缓冲区
P(mutex); //进入临界区
add nextp to buffer;(行为) //将数据放入缓冲区
V(mutex); //离开临界区，释放互斥信号量
V（full）： //满缓冲区数+1
}
}
consumer(){
while(1){
P(full) ; //获取满缓冲区
P（mutex）; //进入临界区
remove an item from buffer; //从缓冲区取出数据
V（mutex） //离开临界区，释放互斥信号量
V(empty) //空缓冲区数+1
consume the item; //消费数据
}
}

死锁

1.概念

1.并发带来的新的问题：死锁：多个进程因竞争资源而造成的一种互相等待。
现象1：2个只可以前进的车在桥的左右2端过桥，桥很窄只可以容纳1辆车通行，
则会出现死锁谁也过不了桥的局面；
现象2：计算机系统只有1台打印机，1台输入设备，
P1正用打印机，同时提出使用输入设备请求，
而P2正用输入设备，而P2又提出使用打印机的请求，这样子便出现互相等待而死锁的情况。

2.死锁产生原因

1.系统资源的竞争
2.进程推进顺序非法
3.死锁产生的必要条件：（必须同时满足以下4个条件）
互斥条件、不可剥夺条件、请求和保持条件（用着1个再要1个）、循环等待条件

3.死锁处理策略：

1.预防死锁：就是破坏死锁产生的4个必要条件之一；
2.死锁避免：
在资源动态分配过程中，防止系统进入不安全状态，效果好；
2.1） 理解下系统的安全状态：也就是进程安全序列；
进入 不安全状态可能进入死锁，而处于安全状态便可以避免死锁；
2.2） 引入银行家算法
他的4个名词：
可利用资源（Available）
最大需求矩阵（Max）
分配矩阵（Allocation）
需求矩阵（Need）
关键公式：Need = Max - Allocation
3）安全性序列算法举例：
系统中5个进程（P0、P1、P2、P3、P4），3个资源（A =10，B= 5 ，C=7）
T0时刻资源分配如下：

进程 Max(A,B,C) Allocation(A,B,C) Available(A,B,C) P0 7 5 3 0 1 0 P1 3 2 2 2 0 0 共同 P0 9 0 2 3 0 2 3 3 2 P0 2 2 2 2 1 1 P0 4 3 3 0 0 2

1.公式计算Need：
753 010 743
322 200 122
902 - 302 = 600
222 211 011
433 002 431
Max Allocation Need
2.用Avaliable 与Need比较，找出满足的
（3，3，2） 》 （1，2，2）对应于P1
（3，3，2） 》 （0，1，1）对应于P3
选择P1暂时加入安全对列，
3.释放P1资源，更新Avaliable
Avaliable = （3，3，2）+（1，2，2）=（5，3，2）
4.同理循环继续处理其他剩下的4个进程
5.得到最终一个安全序列：（P1，P3，P4，P2，P0）

死锁检测和解除

1.死锁定理：当且仅当S状态的资源分配图是不可完全化简的，
2死锁解除：
1）资源剥夺法：挂起死锁进程，并且抢占它的资源，分配给其他死锁进程。
2）撤销进程法：强制撤销部分进程并且剥夺他们的资源
3）进程回退法：退回到足以避免死锁的地步，让其资源释放资源。