2020 操作系统第零天复习（知识点总结）

1：概论

• 批处理系统
  • 是第一个使用多道程序设计的系统
  • 缺少交互性 但是效率提升
• 分时处理系统
  • 把一台计算机按照时间片轮转的方式分配给多个用户，使得用户觉得是自己独占计算机
  • 必须在规定的时间进行响应
  • 交互性增加 响应的时间和CPU的性能，联机终端的数目，所用时间片的长短，系统调度开销和兑换信息的多少
• 实时处理系统
  • 能够实时的查询并且更新数据
  • 机票系统 实时查询系统 飞机 导弹

2：处理器管理

• 处理器状态

  • 核心态和用户态，又叫管态和目态
  • 核心态可以执行所有的指令，目态只能执行用户指令
  • X86 一种有四个特权级，0最高，3最低 但是Windows 中只有两个特特权级
  • 模式切换
  • 用户态到核心态：系统调用，中断或者异常
  • 程序状态字的模式为设置为核心态
  • 核心态到用户态：加载程序状态字特权指令

• 程序状态字

  • 指示处理器的状态，控制指令的执行顺序，并且指示与运行程序有关的信息，主要作用是实现程序状态的保护和恢复
  • 在X86总 PWS由标志寄存器和EIP组成

• 中断的处理

  • 发现中断源
  • 保护现场
  • 转向中断/ 异常时间的处理程序
  • 恢复现场

• 时钟中断是肯定是在用户使用的哈 中断程序是在内核

• 可再入 和可再用

  • 可再入：只读的代码，能够被多个程序同时调用 编译程序
  • 可再用：一次只能一个程序调用

• 进程的特征

  • 【并发性 制约性】【 独立性 共享性】【 结构性】【 动态性】

• 操作系统的特性

  • 异步性 共享性 并发性

并发制约独立动态结构共享

• 进程的状态和转换

  • 三态模型
  • 五态模型
  • 七态模型

• 进程映像

  • 进程控制块
    • 表示信息
    • 现场信息
    • 控制信息
  • 进程程序块
  • 进程核心快
  • 进程数据块

• 上下文切换和模式切换

  • 上下文是不同的进程之间的转换
  • 模式切换是同一个进程下的 内核和用户之间的转变
  • 上下文切换，进程切换一定是在内核空间中的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CgfwqGsg-1610355301000)(C:%5CUsers%5CAdministrator.DESKTOP-CGIO78B%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210111095717447.png)]

• 进程的管理和控制

  • 原语 关中断，不能并发执行 是哦那个房管指令

• 线程

  • 用户级线程：无需模式切换，节省开销
  • 大多数系统调用是阻塞的，一个的阻塞导致整个进程的阻塞
  • 内核级线程：能够利用多个CPU
  • 并且一个线程阻塞之后，也不会导致整个的堵塞
  • 线程在用户时，模式切换的开销太大。用户——内核——用户

typedef struct semaphore{
	int value;
	struct pcb* list;
};

void P(semaphore &s){
	s.value--;
	if(s.value<0){
		W(s.list);   //利用W（s.list)来阻塞自己
	}
}

void V(semaphore &s){
	s.value++;
	if(s.value<=0){
		R(s.list);
	}
}	

管程的实现代码

type struct InterfaceModule{
	semaphore mutex;
	semaphore next;
	int next_count;
}

//enter
mutex=1;
next=0;
next_count=0;

process enter(){
	P(IM.mutex);
}

process leave(){
	if(IM.next_count>0){
		V(IM.next);
	}
	else{
		V(IM.NEXT);
	}
}

process singal(semaphore & x_sem, int & x_count,IM){
	next_count++;
	//唤醒当前信号量上的
	if(x_count>0){
		V(x_sem);
		P(IM.next);
		next_count--;
	}
}


process wait(semaphore & x_sem,int & x_count,IM){
	x_count++;
	if(IM.next_count>0){
		V(IM.next);
	}
	else{
		V(IM.mutex);
	}
	P(x_sem);
	x_count--;
}


哲学家就餐问题
   
    
typedef philiosopher_dinner=monitor
    
enum {hungry,eating,thinking} state[5];    
semaphore self[5];
int selft[5]_count;
for(int i=0;i<5;i++){
    state[i]=thinking;
}
define pickup,putdown;
use enter,leave,putdown,singal

void puton(int i){
    enter(IM);
    state[i]=hungry;
    test(i);
    if(state[i]!=eating){
        wait(self[i],self_count[i],IM);
    }
    拿到左右的两边筷子
    
    leave(IM);
}

void putdown(int i){
    enter(IM);
    state[i]=thinking;
    test((i-1)%5);
    test((i+1)%5);
    
    leave(IM);
}


void test(int i){
    if(state[i]== hungry && state[(i-1)%4]!=eating && state[(i+1)%5]!=eating){
        state[i]=eating;
        singal(self[i],self[i]_count,IM);
    }
}

生产者消费者问题
   process enter(){
	P(IM.mutex);
}

process leave(){
	if(IM.next_count>0){
		V(IM.next);
	}
	else{
		V(IM.NEXT);
	}
}

process singal(semaphore & x_sem, int & x_count,IM){
	next_count++;
	//唤醒当前信号量上的
	if(x_count>0){
		V(x_sem);
		P(IM.next);
		next_count--;
	}
}


process wait(semaphore & x_sem,int & x_count,IM){
	x_count++;
	if(IM.next_count>0){
		V(IM.next);
	}
	else{
		V(IM.mutex);
	}
	P(x_sem);
	x_count--;
}
 
    
typedef produce_customer=monitor
    
semaphore notfull,notempty;
int notfull_count,not_empty;
notfull=0,notempty=0;
notfull_count=0;not_empty_count=0;
int count = 0;


void put(){
    enter(IM);
    if(count==M){
        wait(notfull,notfull_count,IM);
    }
    //进行产品的制作
    count++;
    singal(notempty,notempty_count,IM);
    leave(IM);
}


void putdown(){
    enter(IM);
    if(count==0){
        wait(notempty,notempty_count,IM);
    }
    
    count--;
    singal(notfull,notfull_count,IM);
    leave(IM);
}


读者写者问题
    
typedef reader_writer=monitor
    

semaphore R,W;
int R_count,W_count;
int readcount,writecount;


void startread(){
    enter(IM);
    if(writecount>0){
        wait(R,R_count,IM);
    }
    readcount++;
    
    leave(IM);
}


void endread(){
    enter(IM);
    readcount--;
    if(readcount==0) singal(W,W_count,IM);
    leave(IM);
}


void startwrite(){
    enter(IM);
    writecount++;
    if(writecount>1 || readcount>0 ){
        wait(W,W_count,IM);
    }
    leave(IM);
}

void endwrite(){
    enter(IM);
    writecount--;
    if(writecount>0){
        singal(W,W_count,IM);
    }
    else{
        singal(R,R_count,IM);
    }
    leave(IM);
}

• 进程通信
• 信号
• 管道
• 共享内存
• 消息传递
• 共享内存

死锁防止：

破坏四个必要条件

互斥 保持与申请 不剥削 循环等待

保持与申请：静态分配

不剥削：剥削

循环等待：按需分配 俺层次分配

死锁避免 银行家算法

如果可以收回来，那我才借给你

死锁检测和接触 资源分配图 和死锁定理

设备管理 I/O 硬件原理

• I/O控制方法

  • 轮询
  • 中断
  • DMA
  • 通道
  • 对CPU的影响程度越来越小

• I/O 软件的设计目标 高效率和通用性

  • 考虑的问题
    • 设备通用性
    • 出错处理
    • 同步/异步传输
    • 缓冲技术
  • IO软件的四个层次
    • I/O 中断处理程序
    • I/O 设备驱动程序
    • 独立于设备的 I/O软件
    • 用户空间中的I/O 软件
  • 驱动程序的三功能
    • 设备初始化
    • 执行设备驱动历程
    • 执行中断处理历程
  • 独立于设备的 I/O软件
    • 设备命名和设备保护
    • 提供与设备无关的块尺寸
    • 缓冲技术
    • 设备分配和状态跟踪
    • 错误处理与报告
  • 用户空间的 I/O软件
    • 库函数
    • SPOOLING
      • 作业调度程序 井管理程序 运行作业

• 缓冲技术

  • 单缓冲
  • 双缓冲
  • 多缓冲

• 移动臂调度

  • FCFS 先进先出
  • elevator 电梯调度
  • SSTF 最短查询时间 可能被黏
  • 扫描算法 scan 需要 到头
  • circular scan 循环扫描 单方向

• 文件管理

• 文件的存取方式

  • 顺序
  • 直接
  • 索引

• 文件的逻辑结构

  • 流失 无结构
  • 记录

• 文件的物理结构

  • 顺序
  • 连接
  • 直接文件
  • 索引

• 标准化的操作接口

  • 文件共享
    • 静态共享
    • 动态共享
    • 文件符号链接共享

• 硬盘空间管理

  • 连续分配
  • 非连续分配

• 付村管理方法

  • 位示图
  • 空闲区表
  • 空闲块链
  • 成组链接发