第一章：概述：
1.1，操作系统的主要作用：
1.2，操作系统基本特性：
1.3，操作系统的运行机制与体系结构
1.3.1，运行机制：
①两种指令：
②两种处理及状态：
③两种程序：
1.3.2，操作系统内核：
①时钟管理：计时功能
②中断管理：
③原语：具有原子性
④对系统资源进行管理：进程（cpu）管理 / 存储器（内存/外存）管理 / 设备管理
1.3.3,操作系统的体系结构：
①大内核：将操作系统功能作为一个紧密结合的整体放到内核，由于模块共享信息，因此有很高的性能，但维护不便。
②微内核：
若干服务，相互独立。
1.4，中断异常
①中断分类：
陷入：指令中断
故障：硬件故障
终止：软件中断
②外中断的处理过程：
第二章：进程管理
2.1，进程：
2.1.1，定义：
2.1.2，进程的数据结构：
在多道程序环境下，并发执行程序失去封闭性，具有间断性，结果不可再现性。
为使并发执行的程序（含数据）能独立运行，引入专门的数据结构，PCB。
<1>PCB作为进程实体的一部分，记录了操作系统所需的，用于描述进程当前情况的以及管理进程运行的全部信息
是操作系统中最重要的记录型数据结构。
<2>作用：①使进程可以与其他进程并发，使进程可以间断运行（保存运行状态）。
②提供管理信息。
③提供调度信息（优先级等）
④与其他进程同步通信。
<3>包含信息：①进程标识符（ID）。
②处理机状态（上下文，通用寄存器，指令寄存器，程序状态字，用户栈），用于间断执行，
记录执行状态，恢复现场。
③进程调度信息（优先级等）
④进程控制信息，数据地址，通信机制，资源清单。
2.1.3，进程的基本状态及转换
①就绪态-Ready 已分配到除CPU之外的资源，只有获得CPU就可执行。
②执行态-Running 进程获得CPU正在执行
③阻塞态-Block 正在执行的进程发生事件（IO）或申请内存失败，无法继续执行
2.1.4，进程的控制：
2.2，进程通信：
①共享存储系统：相互通信的进程共享某些数据结构或共享存储器，互斥访问。
②管道通信：互斥，半双工。一方只能将管道写满才能另一个进程读。只有读完才能写。数据读过之后被抛弃
③信息传递系统：不需要借助共享存储器或数据结构，每个进程都有信息缓冲队列，由系统发送，接收原语实现。
④客户机-服务器系统--如Socket.
2.3,线程：
2.3.1，线程分类
①内核支持线程：
②用户级线程：
2.3.2，多线程模型：
①多对一：即多个用户级线程映射到一个内核线程。
+：线程切换开销小（不需要操作系统做状态切换），效率高，
-：并发性不高，内核线程阻塞即用户级线程阻塞。
②一对一：一个用户级线程映射一个内核线程
+：并发性高
-：线程切换开销大
③多对多：如4个用户级线程映射到两个内核线程。
2.3.3，线程与进程的关系与区别：
②进程可以由多个线程组成。
②资源：进程可以拥有资源，线程除本身TCB(线程控制块)等少量自身资源外不拥有资源，同一个进程
中的多个线程共享进程的资源。
③系统开销：进程切换开销大，线程切换开销小。
④独立性：进程拥有自己的内存空间和其他资源，独立性比共享进程内资源的线程高。
2.4，进程同步：
2.4.1，同步与互斥：
2.4.2，临界区：临界资源,如打印机，磁带机等需要互斥访问的资源。进程中访问临界资源的代码称为临界区。
2.5，进程同步方法：硬件同步机制，信号量同步机制，管程机制。（单处理机系统进程同步互斥）
2.5.1,同步原则：空闲让进，忙则等待，让权等待。
2.5.2，硬件同步机制：
①关中断：最简单，关闭中断，进程访问临界区时，系统不响应中断，不存在调度。
-：<1>滥用关中断，后果很严重,<2>关中断时间过长，影响系统效率<3>不适于单处理机系统，其他CPU可响应中断
<4>适用于内核进程，不适用于用户进程。
②Test and Set 指令实现互斥
TS指令(即原语)功能描述：
boolean TS(boolean *lock){
boolean old;
old=*lock;
*lock=TRUE;
return old;
}
实现互斥：
do{
while(TS(&lock))
critial section;
lpck:=FALSE;
remainder section;
}while(TRUE);
+:适合多处理机系统
-:不支持让权等待，会一直在while(TRUE)循环里，出现忙等。
③利用Swap指令：
Swap指令描述：
void swap(boolean *a,boolean *b){
boolean temp;
team=*a;
*a=*b;
*b=temp;
}
实现互斥：
do{
key=TRUE;
do{
swap(&lock,&key);
}while(key!=FALSE);
临界区操作；
lock=FALSE;
....
}while(TRUE);
+:适合多处理机系统
-:不支持让权等待，会一直在while(TRUE)循环里，出现忙等。
2.5.3，信号量机制
原语：是一种特殊程序段，其执行只能一气呵成，由内核程序通过关中断指令实现。
一对原语：wait(s),signal(s)=>P(s),V(s)
void wait(int s){ void signal(int s){
while(s<=0); s=s+1;
s=s-1; }
}
①信号量分类：
整形信号量不能实现让权等待，会出现忙等现象。while()一直占着处理机。
typedef struct{
int value; //剩余资源数
struct process *L; //等待队列
}semaphore;
void wait(semaphore s){
s.value--; //先自减，再锁，value=-1,表示有一个进程再等待
if(s.value<0)
block(s.L); //阻塞原语，挂起进程加入阻塞队列
}
void signal(semaphore s）{
s.value++;
if(s.value<=0)
wakeup(s.L); //唤醒
}
②信号量实现互斥：
semaphore mutex=1;
P1(){
....
P(mutex);
临界区代码；
V(mutex);
...
}
P2(){
...
P(mutex);
临界区代码
V(mutex);
...
}
③实现同步：
<1>设置同步信号量s=0;
<2>在“前操作”后执行V(s);
<3>在“后操作”前执行P(s);
semaphore s=0;
P1(){ P2(){
代码1； P(s);
代码2； 代码4； =>即保证代码4在代码2之后执行。
V(s); 代码5；
代码3； 代码6；
} }
④生产者-消费者问题：
<1>各个进程互斥访问缓冲区 --互斥
<2>缓冲区满，生产者阻塞 --同步
<3>缓冲区空，消费者阻塞 --同步
semaphore mutex=1;
semaphore empty=n;
semaphore full=0;
producer(){
while(1){
生产产品；
P(empty); //缓冲区满了（empty<0）阻塞
P(mutex); //没满，上锁。
将产品放入缓冲区
V(mutex);
V(full);
}
}
consumer(){
while(1){
P(full); //缓冲区空则阻塞
P(mutex); //非空，上锁。
从缓冲区取出一个产品
V(mutex);
V(empty);
使用产品；
}
}
⑤多生产者-消费者问题
<1>盘子：互斥访问，盘空才能放水果 互斥
<2>父亲--女儿 同步
<3>母亲--儿子 同步
semaphore plate=1;
semaphore apple=0;
semaphore orange=0;
dad(){
while(1){
P(plate);
放苹果；
V(apple);
}
}
mom(){
while(1){
P(plate);
放橘子；
V(orange);
}
}
son(){
while（1）{
P(orange);
拿橘子；
V(plate);
吃橘子；
}
}
daught(){
while(1){
P(apple);
拿苹果；
V(plate);
吃苹果；
}
}
⑥吸烟者问题：
<1>缓冲区 互斥
<2>资源1--消费者1， 同步
<3>资源2--消费者2 同步
<4>资源3--消费者3 同步
semaphore offer1=0;
semaphore offer2=0;
semaphore offer3=0;
semaphore finish=0;
int n=0;
producer(){
while(1){
if(n==0){
放资源1；
V(offer1);
}else if(n==1){
放资源2；
V(offer2);
}else if(n==2){
放资源3;
V(offer3);
}
n=(n+1)%3;
P(finish);
}
}
consumer1(){
while(1){
P(offer1);
拿资源1；
用资源1；
V(finish);
}
}
consumer2(){
while(1){
P(offer2);
拿资源2；
用资源2；
V(finish);
}
}
consumer3(){
while(1){
P(offer3);
拿资源3；
用资源3；
V(finish);
}
}
⑦读写者问题
<1>
semaphore rw=0;
int count=0;
write(1){
while(1){
P(rw);
写文件；
V(rw);
}
}
readd(){
while(1){
if(count==0) //
P(rw); // 检测和赋值，不能“一气呵成”，多线程下会出错。
count++; //
读文件；
count--; //
if(count==0) //检测和赋值，不能“一气呵成”，多线程下会出错。
V(rw); //
}
}
<2>修改“一气呵成” 再增加一个信号量，保证原子性。
semaphore rw=1;
int count=0;
semaphore mutex=1;
read2(){
while(1){
P(mutex);
if(count==0)
P(rw);
count++;
V(mutex); =>读进程非常多的情况下写进程会饥饿，
读文件....
P(mutex)；
count--;
if(count==0)
V(rw);
V(mutex);
}
}
<3>解决写饥饿-- 读写公平法
semaphore rw=1;
int count=0;
semaphore mutex=1;
semaphore w=1;--读写公平；
write(){
while(1){
P(w);
P(rw);
写文件...
V(rw);
V(w);
}
}
reader(){
while(1){
P(w); //如果有写进程再等待，该都进程会等待写进程执行完；
P(mutex)；
if(count==0);
P(rw);
count++;
V(mutex);
读文件...
P(mutex);
count--;
if(count==0)
V(rw);
V(mutex);
}
}
⑧哲学家进餐问题
<1>最多只允许N-1个哲学家同时拿筷子；
<2>奇数号先拿左筷子，偶数号先拿右筷子；
<3>只有两边筷子都空闲才允许拿筷子
当哲学家左右筷子都空闲才拿：
semaphore chopstick[5]={1,1,1,1,1};
semaphore mutex=1;
P1(){
while(1){
P(mutex);
P(chopstick[i]);
P(chopstick[(i+1)%5]);
V(mutex);
吃饭；、
V(chopstick[i]);
V(chopstick[(i+1)%5]);
}
}
2.5.4，管程机制
资源管理模块；
①进程与管程的区别：
<1>设置进程是为了实现系统并发性，设置管程是为了解决共享资源的互斥使用问题。
<2>进程调用管程。进程为主动工作方式，管程为被动工作方式。
<3>进程之间可并发执行，管程不能与其调用者并发执行
<4>进程具有动态生命周期，管程则是操作系统中的一个资源管理器模块。
②java中synchrobized关键字修饰函数也保证一段时间内只能被一个线程调用。
2.6,进程调度
2.6.1，进程调度的目标：
①提高资源利用率
②公平
③平衡
④策略强制执行
2.6.2，进程调度的任务：
①保存处理机的现场信息，如程序计数器，多个通用寄存器
②按某种算法选取进程
③把处理机分配给选取的进程
2.6.3，分类：
①高级调度
②中级调度
③低级调度
2.6.4，调度算法：
①FCFS,先来先服务，按任务到达的时间先后顺序进行调度。
②SJF，短作业优先，占用处理机时间短的进程先执行。
-：<1>必须先预知运行时间，<2>对长作业不利<3>不能保证紧迫的作用得到及时处理
③优先级调度：根据紧迫程度给进程制定优先级，FCFS中按等待时间，SJF按运行时间为优先级
④高响应比优先：优先级=（等待时间+需要的处理时间）/需要服务的时间 = 响应时间/需要服务的时间。
①时间片流转法：
②优先级调度算法
<1>静态：进程类型。进程对资源的的要求（SJF，要求少，先执行）。用户要求（用户急需）
<2>动态：动态调整。进程等待长了，提升优先级。进程占用处理机很长时间，降低优先级。
--如高响应比优先调度。
③多级反馈队列--抢占式
新进程申请处理机，则将当前进程暂停放回原i队列尾部。CPU给新进程（第一层优先级高，，抢占式）。
①最早截至时间优先算法：EDF，deadline
②最低松弛度优先算法：松弛度=截止时间-所需时间-当前时间
2.7，死锁：
2.7.1，死锁的必要条件：
①互斥条件： 互 在一段时间内某资源只能被一个进程占用。
②不可抢占条件 不 对已持有的资源，即使他其他资源申请被阻塞，也不释放已有资源。
③请求保持条件： 请（侵） 进程以获取资源，在未使用完之前不能被抢占。
④循环等待条件 环（犯） 哲学家进餐问题中循环等待。
2.7.2，死锁预防：
①破坏“请求保持条件”：允许进程只获得前期的资源便可运行。运行过程中再逐步释放已分配给自己的已用完的全部资源，再申请新的资源。
进程一次申请全部资源，
②破坏“不可抢占条件”：当一个已拥有某些不可抢占资源的进程因为新申请资源被阻塞时，需要释放已有的资源。
③破坏循环等待条件： 对系统资源进行线性排序，每个进程必须按顺序申请资源。
2.7.3，避免死锁：
原文：https://www.cnblogs.com/wangpan8721/p/13959622.html