OS集 just do somthing

tips

定义和功能

操作系统：控制和管理硬件和软件资源，为上层应用软件提供服务，是系统软件
OS是用户和计算机硬件系统之间的接口
用户三种方式使用计算机：系统调用方式；命令方式；图标-窗口方式
OS是计算机系统资源的管理者
OS实现了对计算机资源的抽象

特征

特征：并发，共享，虚拟，异步
并行是同时发生
共享（资源）：互斥共享（同时独一），同时共享
虚拟：空分复用，时分复用
异步：进程以不可预知的速度向前推进，走走停停

OS发展过程

单道批处理系统

缺点：只有一个程序运行，系统中的资源不充分运用，CPU存在等待状态

多道批处理系统

在运行程序A时，利用I/O操作时所暂停的CPU空挡时间来调度另一道程序B运行，反复嵌套，保持CPU忙碌，并发和共享了
缺点：平均周转时间长，无交互能力（批处理都没有）
要解决的问题：处理机争用，内存分配与保护，I/O设备分配，文件组织与管理，作业管理，用户与系统的接口

分时系统

时间片为单位轮流为各个作业服务，相应时间片请求可以被响应，可以实现人机交互
在一台主机上连接了多个配有显示器和键盘的终端所形成系统，该系统允许多个用户同时通过自己的终端，交互方式使用计算机，共享主机的资源
及时接收，及时处理
缺点：时间片公平，没有紧急性

实时系统

系统及时响应外部事件的请求，规定时间内完成对该事件的处理，控制所有实时任务协调一致的运行
主要特征：将时间作为关键参数
特征：多路性，独立性，及时性，交互性，可靠性

核心态啥的

特权指令，非特权指令
CPU用户态只能非特权，CPU核心态可以特权，通过中断实现用户-核心，核心-用户可以直接执行指令
需要执行特权指令的，叫内核程序，其他叫应用程序
中断：内中断和外中断，信号来源是CPU内部（系统调用）还是外部（I/O中断）

系统调用

发生在用户态，处理在核心态。向上的程序接口（与资源相关，会直接影响到其他进程的操作），特殊的函数
库函数：会隐藏一些细节，有点使用系统调用，有的没使用

进程

每个运行程序配置一个PCB（进程控制块）
PCB，程序段，数据段三部分构成进程实体——进程
PCB：进程存在的唯一标准
进程是动态的，是进程实体的运行过程，系统进行资源分配和调度的独立单位
程序段：指令序列 数据段：变量
PCB：操作系统需要的信息（有关进程管理的信息）
进程组织方式：链接，指针直接指向pcb、索引，指针指向索引表

进程的特征

动态性（有一定生命期）、并发性、独立性、异步性

状态

进程的三种基本状态

就绪状态：已准备好运行，只要获得CPU就可以执行，就绪队列
执行状态：已经获得CPU，单处理机只有一个进程处于执行状态，多处理机多个。
阻塞状态：正在执行的进程由于发生某事件（I/O），暂时无法继续执行，多个阻塞队列

创建状态

就绪之前，进程所需的资源没有满足，比如系统内存不够

终止状态

以后不能执行，但在操作系统中有一个记录，保存状态码和一些记时统计数据，供其他进程收集，其他的收集完之后，删除该进程，PCB清零，返回系统。

进程控制

创建新进程、终止已完成的进程、置于阻塞、状态转换等等
原语：若干条命令组成，用于完成一定功能的一个过程，称为原子操作，不可分割，在核心态下执行，开中断/关中断来实现

进程通信

进程之间的信息交换

共享存储

内存中有一个共享空间，互斥的
基于数据结构的共享：共享空间只放10数组
基于存储区的共享：内存中画出一块共享存储区

管道通信

内存里开辟缓冲区，半双工通信
写满不能写，才能读

消息传递

格式化消息
直接通信，每个进程的消息缓冲队列
间接通信：信箱

线程

线程是调度的基本单位了，提高了并发性，同一进程内的系统开销小，TCB，几乎不拥有系统资源
线程实现方式
用户级线程，内核级线程
N:1 1:N N:M

处理机调度

作业：包含了通常的程序和数据，还配有一份作业说明书
高级调度（作业调度）：从外存的后备队列作业中选一个作业调入内存，并为其创建进程，每个作业调出一次，调入一次
中级调度（内存调度）：进程从外存调入内存，本来是挂起状态，pcb还是在内存的，可多次调出，多次调入，挂起的作用是因为这个空间不够用了，你就出去一会
低级调度（进程调度）：从就绪队列中选取一个进程，分配cpu，内存——cpu

进程调度

低级调度，就绪队列上的进程，选择一个分配CPU
时机：
主动放弃：进程正常终止，异常终止，主动请求阻塞
被动放弃：时间片用完，更紧急的事，更高的优先级的进程进入就绪队列
不可调度的情况：处理中断中，该进程在内核程序临界区（会影响内核工作）（普通临界区可以），原语
进程调度方式：

1. 非抢占方式，只允许进程主动放弃cpu
2. 抢占方式——暂停正在执行，重新分配另一个进程

调度算法的评价指标

CPU利用率：CPU忙碌时间/总时间
吞吐量：单位时间内完成作业的数量
周转时间：作业完成时间-作业到达时间
平均周转时间=每个作业的周转时间/作业数
带权周转时间=(作业完成时间-作业提交时间)/作业实际运行时间
平均带权周转时间=每个作业带权的周转时间/作业数
等待时间：等待时间
进程：进程建立后等待被服务的时间之和，等待I/O不算
作业：作业在外存后备队列中等待时间+建立进程后的等待时间
响应时间：用户提交请求到首次响应

调度算法

先来先服务（FCFS）：
作业调度and进程调度，非抢占

进程	到达时间	运行时间	周转时间	带权周转时间	等待时间
P1	0	7	7	1	0
P2	2	4	9	9/4	5
P3	4	1	8	8	7
P4	5	4	11	11/4	7

一边到达一边计算
周转时间=完成-到达
平均周转时间=(7+9+8+11)/4
带权周转时间=周转时间/实际时间
平均带权周转时间=(1+9/4+8+11/4)/4
等待时间：开始-到达=周转-运行
优点：公平简单，不会饥饿
缺点：排在长作业后的短作业带权时间大

短作业优先（SJF）
作业调度and进程调度，带权时间少，非抢占

进程	到达时间	运行时间	周转时间	带权周转时间	等待时间
P1	0	7	7	1	0
P2	2	4	10	10/4	6
P3	4	1	4	4	3
P4	5	4	11	11/4	7

1-3-2-4
平均带权周转时间和，平均都低了
当前已到达且运行时间最短的作业/进程，一边到达一边计算
p1最先，还是p1第一个
平均带权周转时间和，平均都低了
还有一种抢占式的短作业优先 SRTN，那几个平均更低
缺点：不公平，长作业不好，会饥饿

高响应比优先算法（HRRN）
作业and进程，即考虑了等待时间，又考虑了要求服务时间，非抢占
响应比=（等待时间+要求服务时间)/要求服务时间

进程	到达时间	运行时间	周转时间	带权周转时间	等待时间
P1	0	7	7	1	0
P2	2	4	10	10/4	6
P3	4	1	4	4	3
P4	5	4	11	11/4	7

一边到达一边计算
0时只到达了P1，所以P1先算，算完再说
P2：等待了5，(5+4)/4
P3：等待了3，(3+1)/1
P4：等待了2，(2+4)/4
P3出去
P2：等待了9，(9+4)/4
P4：等待了6，(6+4)/4
P2出去
不会饥饿
时间片轮转（RR）
公平地、轮流为各个进程服务，每个进程在一定的时间间隔内都可以相应
仅适用调度，抢占式

进程	到达时间	运行时间	周转时间	带权周转时间	等待时间
P1	0	5	7	1	0
P2	2	4	10	10/4	6
P3	4	1	4	4	3
P4	5	6	11	11/4	7

时间片大小是2，5
到达的时刻插在队尾，但是同时下来的<刚到的

若时间片太大，会退化成先进先出
时间片太小，会变得频繁
不会饥饿

优先级调度
就是自己设置优先级，越高越先
作业and进程，有抢占和非抢占

进程	到达时间	运行时间	优先数
P1	0	7	1
P2	2	4	2
P3	4	1	3
P4	5	4	2

非抢占，一边运行一边上
0时刻，只有p1，上

抢占式

静态优先级——进程的整个优先级不变
动态优先级——要变
适用于实时调度，但是会发生饥饿

多级反馈队列
进程调度，可抢占

进程	到达时间	运行时间
P1	0	8
P2	2	4
P3	5	1

各级优先队列从高到低，时间片从小到大
新进程到达先进入第一级队列，按FCFS排队等待分配时间片
用完时间片进程还未结束，则进程进入下一级队列队尾
若已在最下级，重新放回最下级队尾

被抢占时退回本层

进程同步

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

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

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

硬件同步机制

关中断：实现互斥，直接让这个进程不中断，也就没有其他进程访问临界资源（一个cpu）
缺点：
滥用关中断权力严重后果；关中断时间过长，影响效率；
不适用多cpu
TS（原语）：不可中断 lock：临界区共享变量，false空闲
Swap：对换指令
每个临界资源设置一个全局布尔变量lock，初值是false——让进，局部布尔变量key

信号量机制

因为硬件都没有实现让权等待，信号量机制诞生了
信号量，就是一个变量，可用来表示系统中某种资源的数量
申请：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就挂起

生产者-消费者

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

多生产者-多消费者
一个盘子，甲放苹果，丙吃苹果，乙放梨子，丁吃梨子
（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)

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

存在写饥饿

先读也会只读一次
哲学家进餐（两个临界资源）
五个哲学家，思考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)管程的名称
管程基本特征
数据只能被局限于管程的过程访问
进程只有调用管程内的过程才能进入管程访问共享数据
仅允许一个进程在管程内执行某个内部过程， 一个进程访问管程，其他进程都要阻塞在外面

死锁

一组进程中的每一个进程都在等待该组进程中的其他进程才能引发的事件，该组则是死锁的

资源问题

1. 可重用的资源和可消耗资源
   可供用户重复使用，但是不允许多个进程共享
2. 可抢占和不可
   某进程获得后，还可以收回

引起死锁

1. 竞争不可抢占资源
2. 竞争可消耗资源
3. 进程推进次序不当
   

死锁必要条件

1. 互斥条件——资源互斥性
2. 请求和保持条件——保持了某个资源再请求
3. 不可抢占条件
4. 循环等待条件——每个进程

处理死锁方法

1. 预防死锁//很多条件
2. 避免死锁//一些条件（重要）
3. 检测死锁//任由产生
4. 解除死锁

预防死锁

干掉三个必要条件

破坏请求和保持条件

第一种协议

请求和保持条件——保持了某个资源再请求（破坏掉）
请求资源时，检测是否可分配，如果可分配直接一次性给，中间不会出现请求新的资源
但是会影响效率，资源严重浪费，饥饿现象

第二种协议

允许只获得初期所需资源后，便开始允许

破坏不可抢占

不可抢占变成可抢占

破坏循环等待条件

资源类型排序，编号
一个进程只能按顺序要资源，如果要低的，只能先释放高的
顺序与系统规定顺序不同，浪费

避免死锁

在资源动态分配过程中，计算是否产生死锁，如果有就不分配

系统安全状态

存在安全序列：系统按进程顺序（P1,P2,P3）为其分配资源，直至满足每个进程对资源的最大需求。
并非所有不安全都会死锁

(P2,P1,P3)
避免死锁——确保系统始终处于安全状态

银行家算法

确保贷款时，不会发生不能满足所有客户需要的情况
数据结构

1. 可利用资源向量Available
2. 最大需求矩阵Max
3. 分配矩阵 Allocation
4. 需求矩阵 Need
   Need=Max-Allocation
   （1）$Reques{t}_i[j]<=Need[i,j]$ 不满足出错
   （2）$Reques{t}_i[j]<=Available[i,j]$ 不满足等待
   （3）系统试探着把资源分配了，修改
   
   （4）执行安全性算法，判断分配后是否安全，安全，才正式分配，否则作废
   

已知

P	Allocation	Need	Available
P0	010	743	332
P1	200	122
P2	302	600
P3	211	011
P4	002	432

求：

P	Work	Allocation	Need	Allocation+Work	Finish
P1	332	200	122	532	true
P3	532	211	011	743
P4	743	600
P0	211	011
P0	002	432

死锁的检测和解除

检测

资源分配图，不能消除所有的边，说明发生了死锁

解除

1. 抢占资源
2. 终止或撤退进程，考虑代价最小。。

内存

装入和链接

程序装入内存之后转变为可执行程序
编译：编译程序对用户源程序进行编译，形成目标模块（高级——机器）
链接：目标模块与库函数链接，形成完整的装入模块（形成逻辑地址）
装入：装入模块装入内存（逻辑地址—物理地址）

内存管理

覆盖

对换

调出磁盘
类型
整体对换：进程的代码，数据在外存（PCB还在内存）
页面对换：页面或分段单位进行
目标

1. 对文件区管理
   提高文件存储空间的利用率（离散）
2. 对对换空间管理
   提高进程换入和换出速度（连续）
   数据结构：空闲分区表，空闲分区链

连续分配存储管理方式

内部碎片：分配给进程的内存中没有用上
外部碎片：内存空间中太小不能分配

单一连续分配

连续：连续的内存空间
系统区：存放操作系统相关数据
用户区：用户进程相关数据
内存中只有一道用户程序
优点：简单，无外部碎片
缺点：单用户，有内部碎片

固定分区分配

作业独享分区
多道程序的内存管理方式，
优点：无外部碎片
缺点：有内部碎片
分区说明表：

动态分区分配

进程装入内存时根据进程的大小动态建立分区
数据结构：空闲分区表，空闲分区链
回收情况：
（1）回收区与插入点的前一个空闲F1相邻接
（1）回收区与插入点的后一个空闲F2相邻接
（1）回收区与插入点的前一个空闲F1与后一个空闲F2相邻接
（1）回收区与F1和F2都不相邻接
紧凑

分配算法

选择空闲分区
首次适应算法：最上面开始找，可以就装进去
循环首次适应算法：从上次找到的空闲分区的下一个空闲分区开始找
最佳适应算法：满足要求中最小的
最坏适应算法：每次选最大的
快速适应算法：
将空闲分区根据容量大小进行分类，每一类有相同容量的所有空闲分区，设立空闲分区链，内存中有一张管理索引表
伙伴系统：搜索两倍的分区，分一半，其它为伙伴

分页式存储

一维的，只需要逻辑地址
离散的，内存分物理块，程序分页，要用到一个页面寄存器
页面大小=物理块，一个系统中相同
地址：
前一部分为页号P，后一部分为位(偏)移量W，即页内地址。
图中的地址长度为32位，其中0～11位为页内地址，即每页的大小为4KB，12~31位为页号，地址空间最多允许有1M页
页表
地址变换机构
逻辑地址——物理地址


存储一个数据要访问两次内存，访问内存的页表（形成物理地址），通过物理地址找操作数

快表（高速缓存）

快表存的也是页表项

一次快表访问，一次内存访问
有效访问时间：
基本分页存储：$EAT=t+t=2t$
快表：$$\begin{gathered} EAT=a\times \lambda +(t+\lambda )(1-a)+t=2t+\lambda -t\times a \\ a:命中率 \\ \lambda :查找快表时间 \\ t：访问一次内存所需要时间 \end{gathered}$$

两级页表

外层页表
防止页表太大
本来一张页表是吧，现在加一张页面的页表
访存n+1次

分段存储管理方式

分程序，需要段表寄存器
优点：方便编程、容易实现信息共享、信息保护、动态增长、动态链接

两个参数都要给才能确定
段表
段——内存中一段区域

区别：
（1）页是信息的物理单位，段是逻辑单位
（2）页的大小固定且由系统决定，段不固定
（3）分页的用户程序地址空间是一维的，段是二维的

段页式存储管理方式

段表寄存器

局部性原理

在一较短的时间内，程序的执行仅局限于某个部分
两个局限性：时间和空间

虚拟存储器

具有请求调入功能和置换功能，能从逻辑上对内存容量加以扩充的一种存储器系统
分页请求系统
硬件支持：
（1）请求分页的页表机制
（2）缺页中断机构
（3）地址变换机构
请求分段系统
硬件支持：
（1）请求分段的段表机制
（2）缺页中断机构
（3）地址变换机构

请求分页存储管理方式

硬件支持

请求页表机制
基本分页：

请求分页：

缺页中断机构
在指令执行期间产生和处理中断信号
一条指令在执行期间可能产生多次缺页中断
地址变换机构

请求分页中的内存分配

最小物理块数的确定
内存分配策略
固定分配，全局/局部置换
固定分配全局置换不合理
物理块分配算法
平均分配

置换算法

好——降低缺页率
最佳置换算法
FIFO
BILIDE算法（增加存储块与缺页率）

LRU算法，没有使用的时间最久

7	0	1
7	7	7
	0	0
		1

硬件支持：
寄存器、栈
LFU算法，最少使用
硬件与LRU一样
Clock置换算法（NRU）：周期性
访问：1的变0；0的置换
但是，不想置
换修改过的页面，就改进了（加修改位）
改进Clock置换算法

执行过程就是找不到第一种就找第二种，第二步置0重新开始第一步，再第二部

“抖动”与工作集

全局置换，
调入和调出频繁发生
原因：物理块数少，进程多
工作集：访问的页面确定
抖动的预防方法
局部置换
工作集算法融入处理机的调用
L=S准则调节缺页率
选择暂停的进程

请求分段

存在位，修改位，增补位

文件

文件的逻辑地址

按是否有结构：
有结构（记录式文件）
无结构（流式文件）
按文件组织方式：
顺序文件

索引文件：空间换时间（索引表）
索引顺序文件:分组建表

文件目录

目录管理的要求：
（1）实现按名存取
（2）检索速度快
（3）文件共享
（4）允许文件重名
文件控制块：FCB
基本信息（文件名，文件物理位置，文件逻辑结构，文件物理结构），存取控制信息，使用信息），就是目录项

树形目录结构，无环图目录结构
索引结点：对FCB的改进
除了文件名之外的文件信息，可以加快访问速度

文件组织方式

顺序组织

每个文件在磁盘上占有一组连续的块。支持顺序和直接访问

链接组织

消除外部碎片，提高外存的利用率，对插入、删除和修改记录很容易（挂链位），适应文件动态增长
隐式链接：每个目录项只有指向联接文件的第一个盘块和最后一个盘块 （512-2）
只适用于顺序访问，可靠性差
显试链接：链接文件各物理块的指针显示地存放在内存的一张链表中
FAT表：文件分配表
物理块号 | 下一块
不用访问磁盘，速度比访问磁盘大大减小，支持随机访问，每个磁盘一张表

索引组织

一个文件一张表。不能支持高效的直接存取，要对一个较大的文件进行存取；FAT表太大
单级索引组织方式：
地址/盘块的大小 = 逻辑块号
多级索引组织方式：盘块号装满了，K层，访存K+1

混合索引方式：
增量式索引组织方式——全面照顾

直接地址：4KB
一次间接地址：（一次间址块可存放1K个盘块号——允许文件4MB）

多次间接地址：（比4MB+40K都大8）

i.addr(11)提供二次间接地址，i.addr(12)三次

文件存储空间

空闲表

空闲链表法
位示图
0：空闲；1：已分配

分配(i, j)
$$b=n(i-1)+j$$
回收：
$$\begin{gathered} i=(b-1)DIVn+1 \\ j=(b-1)MODn+1 \end{gathered}$$
成组链接法

空闲盘块号栈

文件共享

删除时count=0
创建link文件，快捷方式

I/O设备

I/O控制器