操作系统学习笔记

最新推荐文章于 2022-03-09 10:59:58 发布

小_月_半

最新推荐文章于 2022-03-09 10:59:58 发布

阅读量260

点赞数

文章标签：操作系统

本文链接：https://blog.csdn.net/m0_46462326/article/details/118338560

版权

操作系统

第一章

计算机系统结构

计算机系统可分为四个部分

hardware ：CPU、内存、IO设备
Operating System：控制各种应用程序和用户之间硬件的使用
Application programs：应用程序
Users：用户

操作系统概念

一直运行在内存下的一系列程序，向下管理分配底层硬件资源，向上为用户和应用程序提供服务和统一接口

内核（kernel）：一直运行着的操作系统

操作系统的发展

大型机计算机系统 Mainframe Computer System
- 批处理系统 Batch Processing System
  
  程序员写代码交给管理员—>管理员攒一批程序，开机一起在大型机上运行—>运行结束将结果返回给程序员
  
  晶体管代替真空管
  
  一个时间段一个程序，CPU效率低
  
  一个程序运行完以后自动切换到下一个程序
  
  主要缺点：无交互能力
- 多道程序系统 Multiprogram System
long-term(JOB) scheduling（choose a good mix job） short-term（CPU） scheduling（fast）

JOB POOL（in DISK）—————————————>memory——————————————————>CPU

select subset of jobs choose one of job
- 分时系统 Time-Sharing System
多用户（Multi_Users）和可交互（Interactive ability）

多道程序系统的逻辑拓展

同时处理多个程序，CPU在多个程序间频繁切换

利用虚拟内存来获取合理响应时间

文件系统和磁盘管理
桌面操作系统 Desktop Operating System

用户便利性（convenience）和响应性（responsiveness）
多处理器系统
- 并行操作系统 Parallel OS
  
  又称为紧耦合系统（Tightly coupled system ）：多处理器在同一主板共享内存和时钟，交互紧密
  - 对称结构 Symmetric multiprocessing (SMP)：每一个CPU对称的，可以运行同一个操作系统的拷贝
  - 非对称结构 Asymmetric multiprocessing
    
    CPU非对称
    
    主处理器master processor接受作业，分配发送给多个从处理器
    
    从处理器slave processors处理作业
    
    一个主处理器对应多个从处理器
- 分布式操作系统 Distributed OS
  
  又称为松耦合系统 Loosely coupled system，交互性不强，不共享内存，广域网连接
  
  优势：
  
  资源共享resources sharing
  
  运算加速 computation speed up
  
  增加可靠性reliability
  
  通信 communications
  
  网络结构：
  
  client-server
  
  peer-to-peer（P2P）
- 集群操作系统 Clustered OS
  
  介于紧耦合和松耦合之间，常用于实验室科学计算，一般不共享内存但共享存储
  - 非对称结构Asymmetric clustering
    
    成对出现，一个用于计算，一个用于监视，计算的出现故障，备胎运行，又叫热备份模式
  - 对称结构Symmetric clustering
    
    多处理器相同，共同处理应用程序
实时操作系统 Real-Time OS

用于工业控制如酸碱滴定测pH或者工业生产控制
- 硬实时系统hard real-time
  
  强制要求限定时间内完成
- 软实时系统soft real-time
  
  尽可能地耗时短，不承诺在规定时间内完成
手持操作系统 Handheld OS

反应速度快

续航好

操作系统结构

device controller：设备控制器，CPU，硬盘，IO设备等都是通过各自的设备管理器sharing memory

设备控制器功能：

控制特定类型的设备

has local buffer and register

通知CPU已通过中断完成了操作

interrupt handling：中断处理，保存当前状态，存储寄存器和程序计数器

IO同步异步：中断发生时，同步：先来后到，异步：先操作中断，再恢复原进程

DMA：“秘书”当CPU需要某种资源时，IO设备控制器将所需要的数据统一存储到缓冲区再发送中断而不是按照字节获取数据并发生中断

存储层次：register->cache->main memory->electronic disk->magnetic disk->optical disk->magnetic tapes

操作系统组成

process management
- process：运行着的程序
- need certain resources
- OS 提供的进程相关的服务
  - 进程的创建和删除
  - 进程的恢复（resumption）和暂停（suspension）
  - 进程的同步，进程间的通信
main memory management
file management
I/O system management
secondary-storage management
networking
protection system
command-interpreter system

第二章

进程

进程概念

进程时运行着的程序，它包括了程序计数器，寄存器，堆/栈，数据部分
进程和程序的区别
- 程序是被动（passive）的实体，例如存储在硬盘上的文件
- 进程是活动（active）的实体，其中程序计数器指向下一条执行的指令和一系列相关的资源
- 两个及以上的进程可能同属于同一个程序的，但他们仍被视为是几个独立的执行序列
进程的状态
- new
- running
- waiting
- ready
- terminated
- Process Control Block（存储进程信息“病历本"）
  - 存储以下7条信息：Process state
    
    Program counter
    
    CPU register
    
    CPU scheduling information
    
    Memory-management information
    
    Accounting information
    
    I/O status information

进程调度

进程调度队列：

job queue ：all processes(job pool)
ready queue ： in main memory, process ready and waiting to execute
Device queues: process waiting for an I/O device

long-term scheduler: select a good process mix from job pool(in disk) to ready queue(in memory)

short-term scheduler: select a process to CPU in short time

medium-term scheduler: 把运行着的进程或者在内存中的进程放回到硬盘中来降低多道程序系统的度，过后将这个进程重新放回到内存中，also called swapping，swapping is necessary to improve the process mix

上下文切换（context switch）保存当前进程，载入新的进程

进程操作

进程的创建
- 父进程子进程共享所有资源
- 子进程拥有父进程的资源的子集
- 不共享资源
- 父进程子进程并发运行
- 父进程waiting
进程中止

协作进程

独立进程

协作进程

优势
- 共享信息
- 计算加速
- 模块化

实现方式

内存共享

bounded-buffer有限缓冲区问题/生产者消费者问题

缓冲区为空：消费者等待
缓冲区满：生产者等待

#define BUFFER_SIZE 10
typedef struct {
	. . .
} item;

item buffer[BUFFER_SIZE];
int in = 0;//缓冲区第一个空位
int out = 0;//缓冲区中第一个有数据的位置

//Inster Method
item nextProduced;
	while (1) {
		while (((in + 1) % BUFFER_SIZE) == out)
			; /* do nothing */
		buffer[in] = nextProduced;
		in = (in + 1) % BUFFER_SIZE;
	}

//Remove Method
item nextConsumed;
	while (1) {
		while (in == out)
			; /* do nothing */
		nextConsumed = buffer[out];
		out = (out + 1) % BUFFER_SIZE;
	}

unbounded-buffer

进程通信

进程间通信（Interprocess Communication（IPC））

Message Passing System
两种原语
- send：将对应的消息发送给消息队列
- receive：从消息队列中取出对应的消息
直接通信
- 对称通信
  - send（p，message）给进程p发送message
  - receive（q，message）从进程q中获取message
  - send receive 的信息都需要接受
  - 通信链接自动完成
  - 两个进程通信只能有一个链路
  - 单向双向
- 非对称通信
  - 只要receive，不要send
- 缺陷
  
  不利于模块化思想的体现：当通信的进程id发生改变时，所有与之通信的进程的通信id都需要改变
间接通信
- 消息发送给mailboxes
- send（A，message）：给mailboxes编号为A的发送message
- 如何避免ABC三个process共享mailbox？
  - 限制链路最多有两个进程（发送接收）同时使用
  - 限制一次只有一个进程可以接受
  - OS随机分配，并告知发送方，是那个进程接收
pipe
进程通信的类型
- blocking阻塞发送（synchronous）：发送方发送后进入waiting状态接收方回复确认收到
- non-blocking（asynchronous）：发送方发送后不进入waiting

线程

线程是CPU运行的基本单元，包含
- program counter
- register
- state
  - running
  - blocked(waiting)
  - ready
- stack
当前线程与同属于一个进程的其他线程共享数据段，代码段和其他资源
是调度和分派的基本单位（进程是资源分配的最小单位，是CPU调度和分派的独立单位）
- 调度（schedule）：多个线程争夺CPU资源，操作系统决定各个进程的顺序
- 分派（dispatch）：将线程加载到CPU中，让其使用CPU资源
传统进程可以看作是单线程的进程
线程id，register，stack，共同组成thread control block（TCB）
进程是资源的拥有者
进程和线程的区别
- 进程的定义：。。。。独立单位
- 进程的属性
  - 并发：并发环境下
  - 动态性：执行
- 进程的内容：包括程序计数器，PCB
- 线程的定义
- TCB包含的内容
- 联系和区别
  - 调度
  - 并发
  - 资源
  - 系统开销
分类
- 用户级线程
  - 提供用户级线程库
  - 跨平台性
  - 早期计算机系统不支持多线程，因此多线程实现在用户级，对内核是透明的
  - 优势
    - 线程的切换十分灵活
    - 可以为进程内部的线程设计独特的调度算法
  - 劣势
    - 当一个进程进入waiting时，该进程的所有线程都进入了blocked状态，无法系统调用
- 内核级线程
  - 基于操作系统进行线程的创建
  - 优势
    - 对于多处理器的设备，一个进程的多个线程可以同时运行
    - 一个线程执行系统调用，其他线程还可以系统调用
    - 更加灵巧的数据结构，速度更快
  - 劣势
    - 从用户空间切换到内核空间后，才能进行所有线程的运行

CPU调度

FCFS（先到先服务）
SJF（最短作业优先）
- 非抢占式（Non-preemptive）
- 抢占式（Preemptive）
SRTF
Priority scheduling
- 可能产生的问题：饥饿
- 解决方法：aging（老化）
RR（round robin时间片轮转法）
多级队列调度
多级反馈队列

进程同步

背景

竞争条件（race condition）：多个进程对共享区的数据并发的访问，而数据的最终值由这几个进程访问的特定顺序决定

解决方法：进程同步

临界区问题（The Critical-Section Problem）

背景：每个进程对共享区域的数据进行操作的代码叫做临界区（每个进程都有一个临界区）（互斥形式访问）
解决方案
- 互斥（mutual exclusion）
  - 一个进程进入自己临界区后，其他进程不能进入自己的临界区
- 前进（progress）：
  - 当一个进程想进入自己的临界区而其他进程不想进入自己的临界区，那么这个想进入自己临界区的进程可以进入自己的临界区
  - 当一个进程刚结束对自己临界区的访问后想再次进入时，其他进程已经进入了自己的临界区，那么这个进程不能再次进入自己的临界区
- 有限等待
  - 当一个进程想进入自己的临界区但其他进程已经进入了自己的临界区，这个想进入自己临界区的进程必须经过有限时间内进入自己的临界区，不能无限制的等待

Peterson‘s 算法

共享变量

int turn; //turn=i，则第i个进程可以进入自己的临界区
boolean flag[2];//flag=true，则进程向进入自己的临界区，当flag=flase，则进程不想进入自己的临界区

//peterson's algorithm
do {
	flag [i] = true;	
    turn = j;	//礼让，先将控制权交给j
    
    while (flag [j] and turn == j) 
        ;
		critical section//进入临界区代码
	flag [i] = false;
		remainder section//离开临界区代码
} while (1);

硬件同步问题（Synchronization Hardware）

硬件指令

原子性，要么都执行，要么都不执行（不许发生中断）

TestAndSet指令

Definition:
         boolean TestAndSet (boolean *target){
               boolean rv = *target;
               *target = TRUE;
               return rv:
          }

作用
- 当输入的布尔指针为true，函数返回true；输入为false，返回false
- 将输入的target指针赋值为true

解决方案

boolean lock=false；//共享变量

while (true) {
          while ( TestAndSet (&lock )) ;   // do nothing
          //    critical section
          lock = FALSE;
          //      remainder section 
    }

Swap指令

Definition:
     void Swap (boolean *a, boolean *b){
              boolean temp = *a;
              *a = *b;
              *b = temp:
      }

作用：交换ab的值

boolean lock = false;共享变量，对于每个进程都有个本地变量名为key


while (true)  {
                    key = TRUE;
                    while ( key == TRUE)
                             Swap (&lock, &key );
					   //    critical section
                     lock = FALSE;
                     //      remainder section 
           }

信号量（Semaphores）

Semaphore S：整数，只有两种原子操作，不可发生中断

wait()，也叫P()
- ```
wait (S){ 
	while (S<= 0)
		 ;  // no-op
    S--;
}
```
- 当信号量S小于等于0，则进入空循环状态，当S>0，–
signal(),也叫V()
- ```
signal (S){ 
	
	S++;
}
```

semaphore mutex = 1;//共享数据


do {
	wait(mutex);
	critical section
 	signal(mutex);	
	remainder section
    } while (1);

信号量的实现

//重新定义信号量
typedef struct {
		        int value;
    			struct process *List;
} semaphore;

//重新定义wait()和signal()
wait(semaphore *S){	
    	S->value--;
		if (S->value < 0) { 
			add this process to S->List;
            block();
		}}

signal(semarphore *S){ 
        S->value++;
		if (S->value <= 0) {
			remove a process P from S->List;
            wakeup(P);
		}}


Block() ;//进程进入等待队列
wakeup(P); //唤醒进程

经典同步问题（Classical Problems of Synchronization）

有限缓冲区问题（bounded-buffer）（生产者消费者问题）

Semaphore mutex = 1;//对共享区域访问互斥
Semaphore full = 0;//定义满项个数
Semaphore empty = N;//定义空项个数

//producer
while (true)  {
    		//produce an item
     		wait (empty);
            wait (mutex);
           	 //  add the item to the  buffer
            signal (mutex);
            signal (full);
     }
//consumer
while (true) {
               wait (full);
               wait (mutex);
               //  remove an item from  buffer
               signal (mutex);
               signal (empty);
               //  consume the removed item
     }

读者写者问题（Reader and Writer Problem）

读者优先问题（第一读者写者问题）

三个条件
- 写者操作，读者等待
- 没有写者，读者不需要等待
- 读者在读的时候，写者向操作，需要等待，其他读者不需要等待

//共享变量
int readcount = 0;
semaphore mutex = 1;
semaphore wrt = 1;

//wirter
while (true) {
               wait (wrt) ;
               //    writing is performed
               signal (wrt) ;
      }      


//reader
while (true) {
              wait (mutex) ;
              readcount ++ ;
              if (readcount == 1)  wait (wrt) ;
              signal (mutex)
              // reading is performed
              wait (mutex) ;
              readcount  - - ;
              if (readcount  == 0)  signal (wrt) ;
              signal (mutex) ;
      }

写者优先问题（第二读者写者问题）

哲学家进餐问题（Dining-Philosophers Problem）

死锁

定义：当一组进程中每一个进程都在等待一个事件，这个事件只能由同组进程的其他等待进程引起，这组进程就叫处于死锁状态
必要条件
- 互斥访问（Mutual exclusion）
- 占有并等待（hold and wait）：拥有资源A，申请资源B
- 非抢占（non-preemptive）
- 循环等待（Circular wait）
资源分配图
- 进程p1拥有r2，申请r1
- 形成环，则可能有死锁
- 无环，则必死锁
- 有环，且每个资源只有一个实例，则有死锁
解决死锁问题的三大策略
- 死锁预防：利用算法，避免死锁的发生，不让系统进入死锁状态
  - 死锁预防（deadlock prevention）：不然系统进入死锁状态
    - 互斥访问：无法轻易实现
    - 占有并等待：系统想要申请资源，则要求其当前不拥有任何资源（先释放再申请）
    - 非抢占：进程拥有一定资源但无法申请新的资源，则该拥有的资源可以被抢占
    - 循环等待：为资源加入序号，只能升序申请资源，不能打乱顺序
  - 死锁避免（deadlock avoidance）
    
    为多个进程寻找安全序列
    - 资源分配图法（所有资源只有一个实例）
      - 需求边----->
    - 银行家算法（资源有多个实例）
      - 安全性算法
        available[]一维数组，available[j]=k表示第j个资源有k个实例
        Max[i] [j]=k:第i个进程对第j个资源的最大需求为k
        allocation【i】【j】=k：第i个进程对第j个资源已经分配k个实例
        need【i】【j】=k：第i个进程对第j个资源还需要k个实例
        need=max-allocation
      - 分配算法
- 死锁的检测与恢复：允许系统进入死锁状态，但系统要有相应的机制来恢复
  - 死锁检测算法
    - 等待图（一个资源只有一个实例）
      - p1指向p2：p1等待p2释放资源
      - 有环则会进入死锁
    - 检测算法（类似于银行家算法）
- 忽略问题

第三章

内存管理

内存定义：内存是一个由硬件实现的大容量的字节数组，并且每一个元素都有自己的绝对的地址
内存分配
- 结构图：
- 连续分配contiguous allocation
  - 单分区single partition allocation
  - 多分区multiple partition allocation
    - 固定分区fixed partition
    - 可变分区variable partition
      - hole：可分配给进程的内存空间
      - 当进程进入内存时如何分配孔
        first-fit
        best-fit
        worst-fit
      - 碎片fragmentation
        external fragmentation进程之外
        internal fragmentation进程之内
        解决方法：compaction（压缩）
- 非连续分配
  - 分页paging
  - 分段segmentation

虚拟内存

背景

按需调页

将所有的页放入二级存储，需要的页放入内存中
有效无效位valid，为1则在内存中，为0在后备存储中
惰性交换：进程在运行之前，所有的页都在二级存储，需要的时候调入内存
页错误：经过查页表，需要的页不在内存中而是在二级存储中

页置换

FIFO

LRU

OPT最优页置换算法

帧分配

操作系统为进程分配帧

fixed allocation

priority allocation

颠簸（thrashing）

原因：内存不够用

解决方法：

局部性原理

第四章

文件系统

文件系统接口

文件的概念（文件是分配磁盘的最小单位）：文件是存储在二级存储中的相关信息的指定集合

文件分类

访问方法

顺序访问
直接访问

目录结构

磁盘：物理上的磁盘

分区：逻辑上的磁盘

卷：逻辑上的分区

目录结构的逻辑目录结构
- 单层目录结构single-level directory
  - 不同文件必须有不同的文件名
- 双层目录结构
- 树状目录结构
- 无环图目录（Acyclic-Graph Directories）
  - 若有环，在删除和遍历的过程中会出现问题，陷入死循环

文件系统的挂接（挂载）

文件共享

拥有者
用户ID
组ID
- 组：具有相同权限的用户的集合

文件保护

文件系统实现

文件系统结构
分层

IO系统

IO接口

分类：

数据传输格式
- 字符设备，例如键盘
  - read，write，seek
- 块设备，例如磁带
  - 指令：get put
访问顺序
- 顺序，例如磁带
- 随机
可共享设备
根据速度
读写，只读，只写

IO子系统

调度
- 基本原则：fairness
缓冲区
Caching：速度慢的设备向速度快的设备拷贝数据
Spooling(假脱机):防止多个进程同时使用的机制
Device reservation（设备预留）

Transforming I/O Requests to Hardware Operations（将IO请求转换为硬件操作）

Performance（性能）

小概念

CPU burst / IO burst CPU区间/IO区间

interrupt中断

trap陷阱

degree of multiprogramming： long-term scheduler

IO-bound process： long time in IO burst

CPU-bound process： long time in CPU burst

CPU利用率

吞吐量（throughput）

周转时间（turnaround time）：ready队列等待时间+在cpu中的运行时间

waiting time：在ready 队列中的等待时间

挂载）