【爆肝四万字！操作系统原理95+】期末考试知识点超超全总结

本文涵盖了笔者本学期学习“操作系统原理”课程的所有重要内容，还包含了一定量的经典例题。纯干货，不废话！目的在于知识的记录，便于今后的回顾，同时也希望对即将考试的朋友们有帮助。

目录

·操作系统概述

操作系统的目标和作用

操作系统的发展过程

操作系统的基本特征

操作系统的主要功能

操作系统典型结构

·操作系统接口

程序接口

·进程管理

进程相关概念

进程的控制

进程的互斥和同步

经典进程的同步互斥问题

生产者-消费者问题

哲学家进餐问题

读者-写者问题

理发师问题

管程

进程通信与线程

·调度和死锁

调度的分级模型

调度算法

实时调度

死锁

银行家算法

·存储器管理

存储器管理导论

程序的装入和链接

存储器分配

固定分区分配

动态分区分配

可重定位分区分配

 对换

分页存储管理

分段存储管理

 有效访问时间（EAT）

虚拟存储器

请求分页存储管理方式

请求分段存储管理方式

·文件管理

文件和文件系统

文件的结构

文件目录

外存分配方式

文件存储空间管理

文件共享与文件保护

·设备管理

I/O系统

I/O控制方式

缓冲管理

设备分配

I/O软件系统层次模型

磁盘存储器管理

---

·操作系统概述

计算机系统是由硬件和软件组成的

硬件是软件建立与活动的基础，是计算机系统实际的物理实现。由运算器、控制器、存储器、输入设备、输出设备组成，通过系统总线连接在一起，实现彼此通信

软件是指计算机系统中运行的程序和数据，对硬件进行管理和功能扩充

计算机系统的资源可以归结为：处理器、存储器、I/O设备、数据和程序

在硬件基础上“覆盖”一些软件，使得计算机系统更加容易使用并且高效。 计算机硬件上的第一层软件就是操作系统（Operating System , OS），OS是计算机必须配置的最基本、最重要的系统软件。 操作系统之上可以继续安装其他的应用软件。

操作系统的目标和作用

操作系统的目标：

1.方便性：可使计算机系统更容易使用

2.有效性：提高系统资源利用率，提高系统吞吐量

3.可拓展性：能够方便地增加新的功能和模块，并且方便地对原有的功能和模块进行修改

4.开放性：系统能遵循世界标准规范，特别遵循开放系统互联（OSI）国际标准。

操作系统的作用：

1.提供用户接口：操作系统提供了用户与计算机系统交互的接口，使用户能够通过命令行界面、图形用户界面或其他方式与计算机进行交互。

2.管理计算机系统的资源：对处理器、存储器、I/O设备、文件等资源进行管理

注：处理器和处理机的区别：处理器一般是中央处理器（CPU），处理机是整个计算机系统中负责执行指令和处理数据的部分。它包括中央处理器（CPU）、寄存器、控制器和执行单元等。但是，"处理机"和"处理器"这两个术语有时被用来指代相同的概念，所以不用太在意细节上的区别。

3.实现了对计算机资源的抽象：使得应用程序开发者可以更专注于应用程序的逻辑和功能，而无需关心底层硬件的细节，同时为用户提供了更方便、更一致的体验。

操作系统发展的推动力：

1.硬件发展：硬件技术的不断进步和发展是推动操作系统发展的重要动力。

2.用户需求变化：用户对计算机系统的需求和期望也是推动操作系统发展的重要动力。

3.新兴技术和领域的挑战：随着新兴技术的崛起，如人工智能、物联网、区块链等，操作系统面临着新的挑战和机遇。

4.器件的不断更新换代：8位机→16位机→32位机→64位机(8位OS →16位OS ... )

操作系统的发展过程

人工操作方式

缺点：1.用户独占全机2.CPU等待人工操作

脱机输入/输出

优点：1、减少了CPU的空闲时间2、提高了I/O速度

单道批处理系统

特点：自动性、顺序性、单道性

缺点：资源和CPU利用不充分

多道批处理系统

特点：调度性、无序性、多道性

优点：提高资源和CPU利用率，增加系统吞吐量

缺点：周转时间长、交互能力差

分时系统

特点：多路、独立、及时、交互

实时系统

特点：多路、独立、及时、交互、可靠

微机操作系统

单用户单任务、单用户多任务、多用户多任务

多处理器操作系统

非对称、对称

网络操作系统

客户服务端模式、对等模式

分布式操作系统

分布、并行、透明、共享、健壮

嵌入式操作系统

例题：试从及时性、交互性、可靠性比较分时系统和实时系统？

及时性：分时系统的及时性是指用户的请求能在很短时间内获得响应，实时系统的及时性是以用户要求的开始截止时间或完成截止时间来确定的

交互性：实时系统的交互性仅限于系统访问某些特定的程序，分时系统向用户提供数据共享等服务

可靠性：实时系统要求系统高度可靠，而分时系统相对可靠性较差

操作系统的基本特征

操作系统定义（不统一）：操作系统是计算机系统中的核心软件，负责管理与控制硬件资源，为用户和应用程序提供一个统一的、方便的、高效的计算环境。

基本特征：

1.并发（最基本特征）：操作系统能够同时管理多个任务，使多个程序能够在同一时间内进行执行。

2.共享（最基本特征）：操作系统可有效地管理和分配计算机中的资源，如内存、处理器、硬盘等，实现资源的共享和利用效率的最大化。

有两种共享方式：互斥共享--临界资源    同时共享--非临界资源

并发和共享是操作系统的两个最基本的特征，它们是互为存在条件的。

3.虚拟：是指通过某种技术把一个物理实体变为若干个逻辑上的对应物。

时分复用技术：操作系统中利用时分复用技术来实现虚拟处理机等，以提高资源利用率。

空分复用技术：操作系统中利用空分复用技术来实现虚拟存储器等，以提高资源利用率。

4.异步性：在多道程序环境下，允许多个程序并发执行，但由于资源有限，进程的执行不是一贯到底的，而是走走停停，以不可预知的速度向前推进。

操作系统的主要功能

1.处理机管理功能

在传统的多道程序设计系统中，处理机的分配和运行，都是以进程为基本单位的，因而对处理机的管理，可以归结为对进程的管理。 在引入线程的OS中，还包含对线程的管理。包含进程控制（创建和撤销进程）、进程同步、进程通信、进程调度

2.存储器管理功能

提高存储器利用率，方便用户使用，并从逻辑上扩充内存。包含内存分配与回收、内存保护、内存映射、内存扩充（空分复用技术实现虚拟存储）

3.设备管理功能

缓冲管理、设备分配、设备处理

4.文件管理功能

文件存储空间管理、文件保护等

5.实现用户接口

命令接口（联机脱机命令）、图形接口（GUI）、程序接口（系统调用）

操作系统典型结构

1.模块化结构

按OS功能划分为若干个具有一定独立性和大小的模块。每个模块具有某方面的管理功能，如进程管理模块、存储器管理模块等。

优点：程序接口紧密、调用简单、效率高

缺点：独立性差、可靠性低

2.分层结构

把操作系统所有的功能模块按照功能的调用次序分别排成若干层，各层之间的模块只能是单向依赖或单向调用

优点：增加、修改或替换层次不影响其他层次，有利于系统的维护和扩充。

缺点：性能损失：分层结构增加了系统的复杂性和开销。资源消耗：每个层次都需要占用一定的系统资源。

 3.微内核结构

特点：足够小的内核、基于客户端-服务器模式、“机制与策略分离”原理、采用面向对象技术

实现的功能：进程管理、低级存储管理、中断陷入处理

·操作系统接口

操作系统的接口分为命令接口、图形接口、程序接口

程序接口

计算机系统中运行的程序可以分为两种类型：一是管理程序，另一类是用户程序。

根据对资源和机器指令的使用权限，将处理机执行时的工作状态分为核心态（管态，kernel mode）和用户态（目态，user mode）。

特权指令：系统态时运行的指令，对内存空间访问不受限制，可访问用户空间，也可访问系统空间 如：启动外设、设置系统时钟、关中断…

非特权指令：用户态时运行的指令，只能访问用户空间，不能直接访问系统中的硬件和软件

程序接口由一组系统调用（System Call)）组成，系统调用实质上是应用程序请求操作系统内核完成某一功能的一种特殊的过程调用。

系统调用和一般过程调用的区别：

系统调用涉及用户态和内核态之间的切换，通常需要较高的开销和权限。一般过程调用是应用程序内部的函数调用，用于执行应用程序自身的逻辑。它在用户态下执行，无需切换到内核态，因此开销较低。系统调用依赖于平台，过程调用不依赖。

系统调用实现：通过中断和陷入机制实现

系统调用处理过程：系统调用→指令中断→信号送入中断和陷入硬件机构→启动中断和陷入处理程序

中断：CPU对系统发生某事件时的一种响应：CPU暂停正在执行的程序，在保留现场后自动地转去执行该事件的中断处理程序；执行完后，再返回到原程序的断点处继续执行。分为外中断和内中断。外中断：由外部设备事件引起的中断，内中断：由CPU内部事件引起的中断，由现行指令引起，也成为“捕获”或“陷入”(trap)

中断处理过程

处理机状态切换(用户态→系统态)

保护被中断进程的CPU现场

转入系统调用处理子程序执行

恢复CPU现场，返回被中断进程或新进程执行

例题：用户程序在需要OS提供某种服务时，是通过系统调用来完成的。请以一个具体例子（如读写磁盘、在显示屏幕上显示字符等）说明系统调用的处理过程。你可以按照一个你熟悉的操作系统（如UNIX、WINDOWS、LINUX）来说明，也可以介绍你自己根据某个硬件环境设计的系统调用的处理过程。

系统调用过程：

用户程序执行到系统调用指令--产生中断--保护现场执行相应指令--结束后恢复现场，返回系统调用的下一个指令继续执行

·进程管理

进程相关概念

进程是程序在一个数据集上的运行过程，是系统进行资源分配和调度的一个独立单位。

从理论角度看，进程是对正在运行的程序过程的抽象

从实现角度看，是一种数据结构

进程的特征：动态、并发、独立、制约、异步、结构

进程和程序的区别

1.进程是动态的，程序是静态的

2.进程=程序+数据+PCB

3.一个进程可以包含多个程序，一个程序可以对应多个进程

进程的静态描述由三部分组成：1.进程控制块PCB，2.有关程序段3.该程序段对其进行操作的数据结构集

PCB是进程存在的唯一标识

PCB包含的信息：进程标识符（进程号）、处理机的状态、进程调度信息（比如：进程状态、进程优先级）、进程控制信息（程序地址等）

PCB组织方式

1.链接方式：把具有同一状态的PCB，用其中的链接字链接成一个队列。形成：就绪队列、阻塞队列、空白队列等 

2.索引方式：系统根据所有进程的状态建立几张索引表。如就绪索引表、 阻塞索引表等。；每个索引表的表目中，记录具有相应状态的某个PCB的首址。

进程的控制

进程的基本状态

就绪态：当一个进程获得了除处理机以外的一切所需资源，一旦得到CPU即可运行

执行态：进程已获得CPU，其程序正在执行

阻塞态：没有所需要的资源，等待资源分配

创建态：系统完成创建进程的一系列工作。只能转换到就绪态。

终止态：进程运行结束或者由于发生错误时，由运行态转到终止态。

原语：把系统态下执行的某些具有特定功能的程序段

在操作系统中，通常把进程控制用的程序段做成原语

进程控制原语：

1.进程创建原语

过程：申请空白的PCB----为新进程分配资源----初始化PCB，填入相关信息----将新进程插入就绪队列

2.进程终止原语

引起进程终止有正常情况和异常情况

过程：根据进程标识符找PCB----如果该进程正在执行则终止----撤销其所有子孙----回收所有资源----移出原在的队列

3.进程阻塞原语

引起进程阻塞的情况：等待I/O操作、等待资源

过程：立即停止执行----把PCB中的进程状态由“执行”改为“阻塞”----插入阻塞队列----进程调度

4.进程唤醒原语

当等待队列中的进程所等待的事件发生时，等待该事件的所有进程都将被唤醒

过程：将PCB从阻塞队列移出----把PCB中的进程状态由“阻塞”改为“就绪”----进程调度或返回

例题：

如果系统中有N个进程，运行的进程最多1个，最少0个；就绪进程最多N-1个最少0个；等待进程最多N个，最少0个

一个状态转换的发生，有可能一定导致另一个转换发生，比如 “运行->就绪”导致“就绪->运行”，“运行->阻塞”导致“就绪->运行”运行-结束 导致 “就绪->运行”，还可以考虑“可剥夺情况”：当一个优先级很高的进程从阻塞转为就绪，有可能直接变为运行态

程序并发执行时为什么会失去封闭性和可再现性？
答： 当系统中有程序并发执行时，系统中的各种资源将为它们所共享，资源的状态也会因为这些程序来改变，致使其中任一程序在运行时，其环境都必然受到其它程序的影响，因此程序并发执行时会失去封闭性。

程序在并发执行时，由于失去了封闭性，其计算结果必将与并发程序的执行速度有关，从而使程序的执行失去了可再现性。

为什么引入进程？

为了能使程序并发执行，并且可以对并发执行的程序加以描述和控制，因此引入了进程的概念

试说明PCB的作用，为什么说PCB是进程存在的唯一标志？

PCB的作用：1、作为独立运行基本单位的标志2、实现进程的同步和通信3、提供进程控制所需要的信息4、提供进程调度所需要的信息

因为系统是通过PCB感知进程的存在的，所以说PCB是进程存在的唯一标志。

说明进程在三个基本状态之间转换的典型原因？

就绪--执行：进程调度，分配了处理机

执行--就绪：进程时间片用完

执行--阻塞：I/O请求

阻塞--就绪：I/O完成

什么是原语？什么时候需要调度进程创建原语？

原语是操作系统在系统态下为完成特定功能的程序段，原语的执行具有不可分割性

进程的互斥和同步

多道系统中，由于进程间的相互联系及资源共享，使进程间可能存在两种形式的制约关系： 间接制约/互斥关系； 直接制约/同步关系；

临界资源:在一段时间内只允许一个进程访问的资源

临界区:访问临界资源的那段程序

进程互斥：不允许两个以上的共享该临界资源的并发进程同时进入临界区的制约关系

互斥的执行原则：

1.空闲让进 2.忙则等待 3.让权等待 4.有限等待

用软件方法解决进程互斥：

方法一：设置标志位flag[i]来标识Pi是否在临界段中，flag[i] 初值为false，表示Pi未使用临界资源。

while (flag[j]) do skip;
flag[i]=true;
critical section;
flag[i]:=false;
remainder section;

问题：当flag[j]和flag[i]都为false时，而且同时都想使用临界资源

方法二：设一整型变量turn来标识何进程可进入临界区。

while turn!=i do skip;
critical section;
turn:=j;
remainder section;

 问题：假设turn此时为j,但是j一直不访问临界区，i想访问，此时就违反空闲让进和让权等待

TS指令解决互斥（硬件方法）

function TS(var lock: Boolean ):Boolean;
begin
TS:=lock;
lock:=true;
end



process Pi
{  while TS(lock) do skip;
          critical section;
     lock:=false;
     remainder section;
}

信号量机制

信号量：仅能由互斥控制原语对其进行操作的整型变量

信号量分类及其意义：

1.二元信号量：用作互斥变量，初值为1；

2.一般信号量：用于一般同步，初值为共享资源初始数量；

互斥控制原语：P/wait操作；V/signal操作；

信号量说明：var s: semaphore;

原语描述    

wait(s)://物理意义：请求分配一个S代表的资源，若s.value<0，表示系统已无该类资源，申请者阻塞。此时， |s.value|表示该信号量上阻塞的进程数
while s<=0 do skip; 
s:=s-1;     
signal(s)://物理意义：进程释放一个S代表的资源，若s.value<=0，表示尚有进程因等待S代表的资源而处于阻塞状态，所以应唤醒其中之一
s:=s+1;

一般信号量机制：

swait(s1,t1,d1,...,sn,tn,dn)        ssignal(s1,d1;...,sn,dn)               
  if s1>=t1 and...sn>=tn            for i:=1 to n do
    then for i:=1 to n do                si:=si+di;
              si=si-di;                    唤醒等待si进程；
           endfor                      endfor;
    else
     将进程插入第一个不满足
     的si队列，重新执行swait操作；
  endif

注意：swait(s,1,1): 蜕化为wait(s);

进程直接制约：并发进程各自的执行结果互为对方的执行条件从而限制各进程的执行速度的过程

进程同步：因直接制约而互相发送消息进而行互相合作等待，使得各进程按一定的速度执行的过程

信号量机制求解进程同步举例：

根据该前驱图的关系，设计执行过程

main( )
{
   semaphore SB=SC=0;
   cobegin
     pa();
     pb();
     pc();
coend;
}
void  pa()
{
  ……
  signal(SB);
  signal(SC);
}
void  pb()
{
  wait(SB);
  ……
}
void  pc()
{
  wait(SC);
  ……
}

经典进程的同步互斥问题

生产者-消费者问题

一个生产者、一个消费者、一个缓冲区

semaphore empty,full;
empty=1,full=0;//初始化
process producer:
{
产生一个物品叫做item
wait(empty);
buffer=item;
signal(full);
}
process consumer:
{
wait(full);
从缓冲区取一个物品item
signal(empty);
消费者消费item
}

一个生产者、一个消费者、n个缓冲区

semaphore empty,full;
empty=n,full=0;
int in=0,out=0;//初始化
process producer:
{
生产者产生一个物品item
wait(empty)
buffer[in]=item;
in=(in+1)%n;
signal(full);
}
process consumer:
{
wait(full);
item=buffer[out];
out=(out+1)%n;
signal(empty);
消费者消耗item
}

n个生产者、m个消费者、k个缓冲区

semaphore mutex,empty,full;
item buffer[k];
int in=0,out=0;
mutex.value=1;
empty.value=k;
full.value=0;//初始化
parbegin//并发进程开始
process produceri (i=1,2,…,m)  //生产者进程
{
     while (true)
    {   …
       生产者产生一个物品item；
         …
       wait(empty) ;	//测试
       wait(mutex);	//互斥
       buffer[in] = item ；
       in = (in + 1)% k ；
       signal(mutex) ;//成对
       signal(full) ;	//交叉成对
   }
} 

process consumerj (j=1,2,…,n）
{  
    while (true)   {
       wait(full);
       wait(mutex);
       item = buffer[out] ；
       out = (out + 1)% k ；
       signal(mutex);
       signal(empty);
       消费者消耗item ;
    }
}
parend //并发执行结束 

哲学家进餐问题

存在死锁的哲学家进餐代码

semaphore chopstick[5] ；
chopstick[0].value=chopstick[1].value=1;
chopstick[2].value=chopstick[3].value=1 ;
chopstick[4].value=1 ; //初始化
parbegin
process  Pi	(i = 0，1，2，3)	       //前4个哲学家
{
    while (true) 
    {  wait (chopstick[i])；                //拿起左边筷子
        wait (chopstick[i + 1])； 	       //拿起右边筷子 
        eating ；                                   //吃面条
        signal (chopstick[i])；             //放下左边筷子
        signal (chopstick[i+1])；         //放下右边筷子
        thinking ；                               //思考
    }
} 
process  P4		       		       //第5个哲学家
{
    while (true) 
    {  wait (chopstick[4])；                //拿起左边筷子
        wait (chopstick[0])； 	        //拿起右边筷子 
        eating ；                                    //吃面条
        signal (chopstick[4])；             //放下左边筷子
        signal (chopstick[0])；             //放下右边筷子
        thinking ；                                //思考
    }
} 
parend

若想要解决上述代码的死锁问题，可以采用下列解决方法之一：

1.仅当哲学家左右两只筷子均可用时，才允许他拿起筷子进餐。

2.规定每个哲学家先拿序号小的筷子——按序号分配。

3.同一时间最多允许1个哲学家进餐(即进餐互斥)。此算法并发程度最差。

以第一种方法为例，使用上述讲过的swait和ssignal编写以下代码：

// 初始化
semaphore chopstick[5] ；
chopstick[0].value=chopstick[1].value=1;
chopstick[2].value=chopstick[3].value=1 ;
chopstick[4].value=1 ; 
parbegin
process  Pi( )         (i=0, 1, 2, 3, 4) 
{
    while (true) 
    {
        int j=(i+1)%5;
        Swait (chopstick[i],chopstick[j])；//拿起左右筷子
        eating ;      //吃面条
        Ssignal(chopstick[i],chopstick[j]); //放下左右筷子
        thinking ;   //思考
    }
} 
parend

读者-写者问题

有两种思路，第一种是读者优先，但这种很容易造成写者“饿死”

所以可以采用第二种，写者优先，待目前正在读的读者读完后，立即让写者去写

代码如下：（此代码较难理解，但是设计极为巧妙，请多多研究）

semaphore Wmutex，Rmutex;
int  Rcounter = 0;  //读者计数变量
Wmutex.value=1;  //写-写互斥、读-写互斥
Rmutex.value=1;   //用于Rcounter互斥
w.value=1 //用于写者优先
parbegin
process Readeri    (i = 1, 2, …) //读者进程
{   wait(w) ; 
    wait(Rmutex); //准备访问共享变量Rcounter
    if(Rcounter==0) wait(Wmutex);
    Rcounter = Rcounter + 1;
    signal(Rmutex);
    signal(w);
     Reading;
    wait(Rmutex);
    Rcounter = Rcounter – 1;
    if(Rcounter==0) signal(Wmutex);
    signal(Rmutex);
} //读者进程结束 
process Writerj (j=1, 2, …)  //写者进程
{
    wait(w)
    wait(Wmutex); 
          //写-写互斥、写-读互斥
    Writing;
    signal(Wmutex);
    signal(w);
}
parend 

对上面的代码做一个简单的解释：

Rcounter用来记录读者目前的数量，当读者目前为0的时候，来了第一个读者，此时如果Wmutex==1，说明此时写者没有来，就可以wait(Wmutex）,Wmutex减为0，此时如果有写者来，就会阻塞，但是！因为此时Rcounter！=0，所以即使再有第二个读者来，也不会阻塞，很好地实现了读读可以一起，但是读写互斥。

Rmutex用于对Rcounter互斥，防止当多个读者同时来的时候Rcounter直接同时运行了两次wait(Wmutex）的情况。

w用于写者优先，读者只要能成功进入，就释放w，之后写者就可以wait(w)，这样的话，相当于“先占个位置”下一个读者来临之时，不可以进入，知道写者写完离开。

理发师问题

semaphore customers,barbers,mutex;
customers.value=0;
barbers.value=0;
mutex.value=1;
int count=0;
parbegin
process barbers:
{
P(customers);
P(mutex);
count-=1;
V(mutex);
cut_hair();
V(barbers);
}
process customers:
{
P(mutex);
if(count

例题

并发进程执行时可能会出现“与时间有关的错误”，这种错误是由于并发进程（ ）引起的。

        A．使用共享互斥资源                 B．执行的顺序性

        C．要求计算时间的长短                 D．程序的长度

答案：A

三个进程P1、P2、P3互斥使用一个包含N(N>0)个单元的缓冲区。P1每次用produce( )生成一个正整数并用put( )送入缓冲区某个单元中；P2每次用getodd( )从缓冲区中取出一个奇数并用countodd( )统计奇数个数；P3每次用geteven( )从缓冲区中取出一个偶数并用counteven( )统计偶数个数。要求某一时刻仅能有一个进程对缓冲区进行操作。请用信号量机制实现这三个进程的同步与互斥活动，并说明所定义的信号量的含义。要求用伪代码描述

int buf;//表示缓冲区
semaphore mutex,S12,S13,empty;
mutex.value=1,S12.value=0,S13.value=0,empty.value=N;
process P1()
{
int num;
while(true)
{
num=produce();
P(empty);
P(mutex);
buf=put(num);
V(mutex);
if(num%2==0)V(S13);//偶数
else if(num%2==1)V(S12);//奇数
}
}
process P2()
{
int odd;
while(true)
{
P(S12);
P(mutex);
odd=getodd(buf);
V(mutex);
V(empty);
countodd();
}
}
process P3()
{
int even;
while(true)
{
P(S13);
P(mutex);
even=geteven(buf);
V(mutex);
V(empty);
count(even);
}
}
main()
{
cobegin
process P1();
process P2();
process P3();
coend
}

某寺庙有大、小和尚若干，有一水缸。由小和尚挑水入缸供老、大和尚饮用。水缸可容10桶水，水取自同一井。水井很窄，每次只能容一个水桶取水。水桶总数为3个。每次入、取缸水仅为1桶，且不可同时进行。试给出取水、入水的同步算法

semaphore mutex1,mutex2,count,full,empty;
mutex1.value=1,mutex2.value=1,count.value=3,full.value=0,empty.value=10;
process 小和尚Pi(i=1,2,3...)
{
while(true)
{
wait(empty);
wait(count);
wait(mutex1);
从井中取水
signal(mutex1);
wait(mutex2)
把水放入缸中
signal(mutex2);
signal(count);
signal(full);
}
}
process 老和尚Pj(j=1,2,3...)
{
while(true)
{
wait(full);
wait(count);
wait(mutex2);
从缸中取水
signal(mutex2);
signal(count);
signal(empty);
}
}

main()
{
cobegin
小和尚P1();
老和尚P1();
小和尚P2();
老和尚P2();
......
coend;
}

一条河上架设了由若干个桥墩组成的一座桥。若一个桥墩只能站一个人，过河的人只能沿着桥向前走而不能向后退。过河时，只要对岸无人过，就可以过。但不允许河对岸的两个人同时过，以防止出现死锁。请给出两个方向的人顺利过河的同步算法。

int countA=0,countB=0;
semaphore SA,SB,mutex;
SA.value=1,SB.value=1,mutex.value=1;
process Ai()
{
wait(SA);
if(countA==0)wait(mutex);
countA++;
signal(SA);
过桥
wait(SA);
if(countA==0)signal(mutex);
countA--;
signal(SA);
}

process Bi()
{
wait(SB);
if(countB==0)wait(mutex);
countB++;
signal(SB);
过桥
wait(SB);
if(countB==0)signal(mutex);
countB--;
signal(SB);
}

main()
{Cobegin
A1(),A2(),.......
B1(),B2(),.......
CoEnd
}

解释：由于每一个桥墩可以站一个人，同一方向可以走多个人，但不能两个方向的人同时过，所以对于每一个方向，首先判断这个方向上的人数是不是0，如果是就去申请mutex，不是的话，说明桥目前已经是这个方向的“主场”了，直接过桥就可以了，在判断人数之前首先要设置一个互斥量比如SA，因为如果不设置，就可能同时countA+=2，桥墩就站了两个人，过完桥后，只有这个方向上的人全走过去了才释放mutex。

管程

管程的基本思路是：把分散在各进程中的临界区集中起来进行管理，并把系统中的共享资源用数据结构抽象地表示出来。

一个管程定义了一个数据结构和能被并发进程执行(在该数据结构上)的一组操作，这组操作能同步进程和改变管程中的数据

管程的组成：

1.局部于管程的共享变量说明；

2.对该数据结构进行操作的一组过程；

3.对局部于管程的数据设置初值的语句。

管程把共享变量和对它的操作的若干过程“封装”起来，所有进程要访问临界资源时，都必须经过管程才能进入，而管程每次只准许一个进程进入管程，从而实现了进程互斥。

利用管程实现进程同步时，必须设置两个同步操作原语wait和signal。 某进程通过管程请求临界资源未能满足时，管程调用wait原语将该进程阻塞，并把它排到等待队列上，如图2-11。 当另一进程访问完成并释放该资源后，管程调用signal原语唤醒等待队列中的队首进程。

x.signal的操作与信号量中的signal操作不同。 x.signal操作的作用，是重新启动一个被阻塞的进程，但如果没有被阻塞的进程，则x.signal操作不产生任何后果。而信号量中的signal总是要执行s=s+1操作，因而总是要改变信号量的状态。

进程通信与线程

进程通信：进程之间的信息交换

进程之间的互斥和同步，涉及PV操作的信号量机制是低级通信。

高级通信是指用户可直接利用OS所提供的一组通信命令，高效地传送大量数据的一种通信方式。 高级通信过程对用户是透明的。大大减少了通信程序编制的复杂性。  

高级通信机制分类：

1.基于存储器系统

基于共享数据结构（如生产者-消费者）和基于共享存储区

2.管道通信

管道：用于连接一个读进程和一个写进程以实现它们之间通信的一个共享文件

3.基于消息传递系统

直接通信和间接通信（使用信箱，既可以实时，又可以非实时）

为什么引入线程？为了减少进程切换和创建的开销，提高执行效率和节省资源，将进程独立性的两个属性（调度的基本单元和资源分配的基本单元）分开，引入了线程

引入之后——进程是资源分配的单位，而线程是处理机调度的单位。

多线程编程的优点：

1.响应程度高，提高执行效率 2.资源共享，节省资源

进程和线程的比较：

1.地址空间：不同进程的地址空间必然不同，但是在同一进程的不同线程的地址空间相同

2.调度：没有线程，进程是处理机调度单位，有了线程，线程才是调度单位

3.并发性：同一进程和不同进程的不同线程均可并发执行

线程分类：内核级线程、用户级线程、组合式线程

例题：

试从系统资源管理、处理机调度、资源利用率、优势等几个方面对比说明下进程与线程的区别？

资源管理：进程是资源分配的基本单位，它拥有自己的资源和地址空间，多个线程共享一个进程的内存空间和资源

处理机调度：线程是处理机调度的基本单位，进程的调度大多是操作系统完成，线程可以由操作系统完成，也可以由用户程序完成

资源利用率：以进程为单位的调度，设计很多资源转移问题，资源利用率低。引入线程之后，资源利用率大大提高

优势：多线程系统中，使用线程可以提高进程内任务执行的并发度，减少用户等待时间，提高系统响应时间

·调度和死锁

调度的分级模型

作业和作业的状态转换

用户提交的作业通过相应的输入设备输入到磁盘存储器，并保存到一个后备作业队列中，再由作业调度程序将其由外存调入内存。

作业的标识：作业控制块 （JCB）

作业状态和状态之间的转换

作业四个状态：1.提交状态2.收容状态3.执行状态4.完成状态

处理机的调度层次：

1.作业调度：按一定的原则对外存输入井上的大量后备作业进行选择，给选出的作业分配内存、输入输出设备等必要的资源，并建立相应的进程，以使该作业的进程获得竞争处理机的权利。另外，当该作业执行完毕时，还负责回收系统资源

2.交换调度：涉及内存管理的知识（后面章节），主要的任务是将处于外存交换区中的就绪状态或等待状态的进程调入内存，或把处于内存就绪状态或内存等待状态的进程交换到外存交换区

3.进程调度：按照某种策略和方法选取一个处于就绪状态的进程占用处理机

4.线程调度：在有线程的操作系统中，线程调度是指按照特定策略为某个线程分配CPU的使用权

多道批处理系统中：作业调度和进程调度

分时系统和实时系统中：进程调度、交换调度和线程调度。

调度目标：

1.对所有作业应该是公平合理的

2.应使设备有高的利用率

3.每天执行尽可能多的作业

4.快的响应时间

性能指标：周转时间、平均周转时间、带权周转时间、平均带权周转时间

调度分为：抢占式和非抢占式

调度算法评价：

定性：可靠性、简洁性

定量：CPU利用率、平均带权周转时间

调度算法

1.FCFS

用于作业调度：从作业后备队列中，选择一个或几个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入进程就绪队列

用于进程调度：从就绪队列中，选择一个最先进入该队列的进程，为之分配处理机

2.SJF/SPF

选择运行时间最短的作业/进程（非抢占式）

优点：使平均周转时间最短

缺点：对长作业不利，不考虑作业急迫性

3.高优先权优先调度（抢占式/非抢占式）

选择优先权最高的作业/进程

静态优先权、动态优先权

4.高响应比优先调度（作业调度）

响应比：(等待时间+要求服务时间)/要求服务时间

优点：结合了FCFS和SJF的优点

缺点：增加开销，每次调度都要计算响应比

5.时间轮转调度算法（进程调度）

6.多级反馈队列调度算法

 原理：

1、设有N个队列（Q1,Q2....QN），其中各个队列对于处理机的优先级是不一样的，也就是说位于各个队列中的作业(进程)的优先级也是不一样的。一般来说，优先级Priority(Q1) > Priority(Q2) > ... > Priority(QN)。怎么讲，位于Q1中的任何一个作业(进程)都要比Q2中的任何一个作业(进程)相对于CPU的优先级要高（也就是说，Q1中的作业一定要比Q2中的作业先被处理机调度），依次类推其它的队列。
2、对于优先级最低的队列来说，里面是遵循时间片轮转法。也就是说，位于队列QN中有M个作业，它们的运行时间是通过QN这个队列所设定的时间片来确定的；对于其他队列，遵循的是先来先服务算法，每一进程分配一定的时间片，若时间片运行完时进程未结束，则进入下一优先级队列的末尾。
3、各个队列的时间片是一样的吗？不一样，这就是该算法设计的精妙之处。各个队列的时间片是随着优先级的增加而减少的，也就是说，优先级越高的队列中它的时间片就越短。同时，为了便于那些超大作业的完成，最后一个队列QN(优先级最低的队列)的时间片一般很大(不需要考虑这个问题)。

实时调度

实现实时调度的基本条件：

 采用多处理机系统，假设系统中处理机数为N，则应将上述限制条件改为：

 实时调度需要：

1.提供必要信息2.系统处理能力强3.采用抢占式调度机制4.具有快速切换机制

非抢占调度算法和抢占调度算法：

非抢占式算法： 非抢占轮转调度和非抢占优先权调度

抢占式算法：基于时钟中断的抢占式优先权调度算法和立即抢占的优先权调度算法

常用的几种实时调度算法：

1.最早截止时间优先算法

可用于抢占式调度，也可用于非抢占式调度

2.最低松弛度优先算法（抢占式）

松弛度的计算： 一个任务在150ms之前必须完成，它本身需要运行100ms，则该任务的紧急程度(松弛程度)为50ms

需要注意，此处的“抢占式”不是说就绪队列有一个松弛度比处于执行态进程的松弛度低的就会立即把正在执行的进程“取代”，而是只有当此就绪态进程松弛度为0时，才抢占

比如：在一个实时系统中，有2个周期性实时任务A和B，任务A要求每20ms执行一次，执行时间为10ms；任务B要求每50ms执行一次，执行时间为25ms。

调度前三步如下：

10s时，A松弛度为20ms，B松弛度为15ms，调用B，但是当t=15ms之后，A的松弛度就比B低了，但是并没有抢占，直到t=30s，A松弛度为0ms，才发生抢占！

在采用动态优先权的调度算法中，如果所有进程都具有相同优先权初值，则此时的优先权调度算法实际上和_fcfs___调度算法相同

例题

1、计算机系统中存在着哪几种可能的调度？各自的主要工作是什么？

高级调度（作业调度）：从外存中输入井的后备作业按照一定原则，给其分配内存资源，建立相应的进程，分配处理机，使作业由收容状态进入执行状态，当执行完成之后，还负责回收其资源。

中级调度（交换调度）：涉及存储器管理，按照一定策略，将内存中阻塞的进程放到外存的交换区（连续分配空间）、将外存交换区中就绪的进程放到内存

低级调度（进程调度）：按照某种策略和方法选取一个处于就绪状态的进程占用处理机

2、进程调度的时机有哪些？

正在执行的进程执行完毕
时间片用完
在CPU执行方式是可剥夺时，就绪队列中某进程的优先级高于当前执行进程的优先级时将引起进程调度
执行中的进程因为某种原因从运行状态转入阻塞状态

3、作业调度的性能评价标准有哪些？请结合批处理系统、分时系统、实时系统的特点，说明这几个系统在作业调度性能评价上有什么不同的侧重点和需求？

平均周转时间/平均带权周转时间，平均响应时间，吞吐量、平均等待时间、CPU利用率
对于批处理系统，对于作业的平均周转时间或平均带权周转时间要求较高。
对于分时系统，除了要保证系统吞吐量，资源利用率高之外，所以分时系统中，仅用周转时间来衡量调度性能是不够的，平均响应时间是衡量调度性能的一个重要指标。
实时系统中，任务的执行往往有截止时间要求，因此实时系统中满足用户的时限时间是一个重要指标。

4.

用银行家算法考虑下列系统状态 ：

进程     分配矩阵       最大需求矩阵       资源总数矩阵

 A      3  0  1  1       4  1  1  1                  6  3  4  2

 B      0  1  0  0       0  2  1  2

 C      1  1  1  0       4  2  1  0

 D      1  1  0  1       1  1  1  1

 E      0  0  0  0       2  1  1  0

问：

(1)此时系统是否安全？为什么？

(2)若进程B请求(0,0,1,0)，可否立即分配？

(3)此后进程E也请求(0,0,1,0)，可否分配给它？

1.存在安全分配序列：deabc

2.安全 deabc

3.不安全，接着第二小问若再给E，则资源就剩下：1000，谁都分不了了

死锁

死锁：多个进程在运行过程中因争夺资源而造成的一种僵局

产生死锁的必要条件：

1.互斥条件：进程所分配到的资源是临界资源

2.请求和保持条件：进程提出了新的资源请求，但又对自己已获得的资源保持不放

3.不剥夺条件：进程已获得的资源，在未使用完之前，不能被剥夺

4.环路等待条件：发生死锁时，存在进程-资源的等待链

处理死锁的基本方法：

1.预防死锁：破坏产生死锁的四个必要条件中的一个或几个条件（限制条件严格）

2.避免死锁：在资源动态分配过程中，用某种方法防止系统进入不安全状态（银行家算法）

3.检测死锁：允许系统在运行过程中发生死锁，但可通过系统设置的检测机构，及时检测出死锁的发生，然后采取适当的措施，从系统中将已发生的死锁清除掉

4.解除死锁：常用的方法是撤消或挂起一些进程，以便回收一些资源，分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行（实际难度最大）

预防死锁：

1.破坏互斥的必要条件

采用Spooling技术，可以允许若干个进程同时产生输出

2.摒弃“请求并保持”条件

资源的一次性分配

3.摒弃“不剥夺”条件

当一个进程已经保持了某些资源，再提出新的资源请求而不能满足时，必须释放它已经保持了的资源，待以后需要时再重新申请

4.摒弃“环路等待”条件

采用资源“按号分配”

银行家算法

安全状态：系统能按某种进程顺序P1，P2，…，Pn（称为安全序列），来为每个进程P分配其所需资源，直至满足每个进程对资源的最大需求

不是安全状态就是不安全状态

并非所有不安全状态都是死锁状态，但它迟早会进入死锁状态

银行家算法: 在资源分配过程中，若分配后系统状态仍是安全的，则同意分配，否则拒绝分配

银行家算法所使用的数据结构

1.可利用资源向量Available

2.最大需求矩阵Max

3.分配矩阵Allocation

4.需求矩阵Need

关系：Need [ i，j ] = Max [ i，j ] – Allocation [ i，j ]

银行家算法的步骤：

银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。

1.如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转(2)；否则，出错。

2.如果REQUEST [cusneed] [i]<= AVAILABLE[i]，则转(3)；否则，等待。

3.系统试探分配资源，修改相关数据：

AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

4.系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待

安全性检查的步骤：

1.设置两个工作向量Work=AVAILABLE;FINISH

2.从进程集合中找到一个满足下述条件的进程，

FINISH==false;

NEED<=Work;

如找到，执行（3)；否则，执行（4)

3.设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work=Work+ALLOCATION;

Finish=true;

GOTO 2

4.如所有的进程Finish= true，则表示安全；否则系统不安全

银行家算法举例：

 1.在这种情况之下，系统是否安全？

存在着一个安全序列{P1,P3,P4,P2,P0}，故系统是安全的

2.P1发出请求向量Request1（1，0，2），按银行家算法，分析系统是否可同意请求？

Request1(1,0,2)≤Need1(1,2,2)

Request1(1,0,2)≤Available(3,3,2)这两个条件都可以满足，那么假设可以同意请求，则对分配之后的系统进行安全性检查，发现，发配之后，存在安全序列{P1,P3,P4,P2,P0}，故系统安全

---

上面学习了死锁的预防（破坏死锁产生的条件）和避免（银行家算法），下面学习死锁的检测和解除

死锁的检测：

1.资源分配图法

 这就是一种死锁的例子，P4占有R4而等待R3，P5占有R3,而等待R5，P7占有R5而等待R4

涉及多个资源时，资源的方框中用点表示资源数目，此时，即使是有环也不一定死锁，可以化简资源图，如果可以化简到所有进程结点都成为孤立结点，那么就一定不会产生死锁，反之会产生（死锁定理）

2.安全性检测算法（银行家算法中已经讲过，此处不赘述）

3.Warshell传递闭包算法（不适用于每类资源有多个的情况）

首先构造矩阵：

 伪代码

      for  k := 1  to  n  do
           for  i := 1  to  n  do
                for  j := 1  to  n  do
                     bij(k) := bij(k-1) ∨(bik(k-1)∧bkj(k-1))

 当死锁检测程序运行上述程序后，矩阵中有某个bii取值为“1”时，就表示存在一组进程，它们循环等待资源，即出现了环路(死锁)。

比如说最终b11=b22=b33=1，则进程p1、p2、p3都死锁

死锁的解除：

1.剥夺资源

2.撤销进程

3.鸵鸟算法

例题

1.假设3个进程共享4个同类资源，每个进程最多需要2个该类资源，每个进程一次只能申请/释放1个资源，证明该系统不会因竞争该类资源而死锁

根据“鸽笼原理”，必然有一个进程可以获得2个资源，直到执行完毕后释放资源，资源再给其它进程，最后所有进程执行完毕

2.某系统有同类资源m个供n个进程共享，如果每个进程最多可能需要x个资源(1≤x≤m)且各进程的最大需求量之和小于(m + n)。证明系统没有因申请该类资源而发生死锁的危险

证明：若系统会死锁，则n(x-1)+1≤m一定不成立，即n(x-1)+1＞m成立。于是nx＞m+n-1，推得nx≥m+n，与题意nx＜m+n矛盾，故系统不会死锁

3.死锁预防是保证系统不进入死锁状态的静态策略，其解决办法是破坏产生死锁的四个必要条件之一。下列方法中哪是一个破坏了“循环等待”条件(     )

   A.银行家算法            B.资源有序分配策略  

   C.剥夺资源法            D.一次性分配策略

答案:B

·存储器管理

存储器管理导论

存储器管理功能：1.内存分配与回收2.内存保护3.地址映射4.内存扩充（虚拟存储技术）

存储器的层次结构：越往上，价格越高，容量越小，速度越快

 

主存储器（Main Memory）：主存储器是计算机系统中用于存储数据和指令的关键组件。它是CPU可以直接读取和写入的存储空间。主存储器通常是随机访问存储器（RAM）的形式，支持按照指定地址进行随机访问操作。它的容量决定了系统可以存储的数据和指令的大小。主存储器具有较快的访问速度，但是容量相对较小，并且在断电时会丢失其中的数据。

寄存器（Registers）：寄存器位于CPU内部，是CPU用于存储和执行指令的最快速的存储设备。寄存器的容量非常有限，通常用于存储当前执行指令和处理器状态所需的数据。寄存器具有非常快的访问速度，因为它们直接嵌入在CPU中，可以立即获得访问。

高速缓存（Cache）：高速缓存是位于CPU和主存储器之间的中间层次存储器。它用于暂时存储CPU频繁使用的数据和指令，以加快访问速度。高速缓存具有比主存储器更快的访问速度，但容量相对较小。它采用缓存替换策略，根据数据的局部性原理，将最常用的数据和指令存储在其中，以便CPU可以更快地访问。高速缓存通常分为多个级别，如一级缓存（L1 Cache）、二级缓存（L2 Cache）等，每个级别的访问速度和容量不同。

磁盘缓存（Disk Cache）：磁盘缓存是位于磁盘驱动器和主存储器之间的缓存层次，用于加速对磁盘上数据的访问。磁盘缓存通常是靠近磁盘驱动器的一块内存区域，用于存储最近读取的和写入的数据块。当系统需要从磁盘读取数据时，它会首先检查磁盘缓存中是否存在所需数据，如果存在，则可以直接从缓存中读取，从而实现更快的访问速度。磁盘缓存可以通过减少对磁盘的实际访问次数来提高系统性能。

逻辑地址：目标程序使用的地址单元(相对地址或虚地址)。一个用户作业的目标程序的逻辑地址集合称为该作业的逻辑地址空间

物理地址：主存中的实际存储单元编号(绝对地址或内存地址)。物理地址的总体构成物理地址空间

重定位：程序和数据的逻辑地址转换为物理地址，分为动态重定位和静态重定位

程序的装入和链接

程序装入的三种方式：

1.绝对装入方式（仅适用单道程序设计环境）

2.可重定位的装入方式（采用静态重定位）

3.动态运行时装入（采用动态重定位）

程序链接的三种方式：

1.静态链接

2.装入时动态链接

3.运行时动态链接

存储器分配

1.连续分配方式（分区管理方式）：固定分区分配、动态分区分配、可重定位的分区分配

2.离散分配方式：分页存储管理、分段存储管理、虚拟存储器

固定分区分配

分区大小相同和不相同都可以，但是必须固定

缺点：动态扩充困难、内存利用率太低、大作业可能无法装入

动态分区分配

空闲分区表的组成：分区号、分区始址、分区大小

基于顺序搜索分配算法：首次适应、循环首次适应、最佳适应、最坏适应

回收内存可能出现的四种情况：

基于索引搜索的分配算法：快速适应、伙伴系统、哈希算法

可重定位分区分配

目的：解决碎片问题

方法：进行碎片的拼接或紧凑

为使地址转换不会影响到指令执行速度，必须有硬件地址变换机构——专设两个控制寄存器：基址寄存器和限长寄存器

 对换

对换：把内存中暂时不能运行的进程调出到外存上，以便腾出足够的内存空间，再把已具有运行条件的进程，调入内存

可以把外存分为：文件区（离散分配：提高内存利用率）和对换区（连续分配：提高进程换入换出速度）

换出：选择阻塞队列中优先级最低的进程

换入：找出“就绪”状态但已换出的进程，将其中换出时间最久的进程换入

分页存储管理

页面（页）：逻辑地址空间分成的若干个大小的片

物理块（页框）：内存空间分成与页大小相同的若干存储块

分页的逻辑地址可以分解为：页号+页内偏移地址（此偏移量也称为页内地址）

假设地址总长度为32位，页号占20位，页内偏移地址占12位，则：

总共有2^20（1M）个页，每页大小为2^12（4KB）

页表：记录相应页在内存中对应的物理块号，实现从页号到物理块号的地址映射

基本的地址变换机构：

设计一个页表寄存器存放页表始址和页表长度，在已知逻辑地址（包含页号P和页内地址W）的情况下，由公式：页表内地址=页表始址+ P*页表项长度得到页表对应页号的物理地址，通过这个物理地址读取页号对应的物理块号，再由公式物理地址=b*L+W (L为页的长度，b为块号)得到最终地址。

例题：在一分页存储管理系统中，逻辑地址长度为24位，页面大小为4096B，现有一逻辑地址为2FA6H，且第0、1、2页依次存放在物理块10、12、14中，问相应的物理地址为多少？

页面大小4096B，故页内偏移量为12位，在16进制数的表示中占3位，一逻辑地址2FA6H，直接得到页号为2H，页内偏移量FA6H，对应物理块14,为十六进制的E，所以最后答案为EFA6H

具有快表的地址转换机构：

内存管理单元将页号送入高速缓存，将此页号与高速缓存中所有页号同时比较，若有匹配的页号，则将其对应的块号送物理地址寄存器中。若在快表中未找到对应的页表项，则还需访问内存中的页表，找到后，把从页表项中读出的块号送物理地址寄存器；同时，再将此页表项存入快表的一个寄存器单元中，亦即修改快表。如果快表已满，则OS必须淘汰一个老的页表项。

 两级页表：

如图所示

多级页表：

需要注意的是采用多级页表机制时，各级页表的大小不能超过一个页面

举例：已知某系统页面长4KB，页表项4B，采用多级页表映射64位虚地址空间。若限定最高层页表占1页，问它可以采用几级页表？

根据题意，一个页面有记录4KB/4B=1000个。64位虚拟地址空间共有页面2^64/4KB=2^52个。由于每层页表的大小都不超过一页，所以每层的页号不超过10位。由于层数n需要满足不等式10×n+12≥64，所以采用6层。

为了实现分页存储管理，需要什么硬件支持？

1.地址转换机制：分页存储管理中，需要有硬件支持进行逻辑地址到物理地址的转换。这包括地址转换机制，通常使用内存管理单元（MMU）来实现。

2.分页机制支持：硬件需要支持分页机制，其中包括用于划分逻辑地址空间的页大小定义和确定。

分页大小：硬件需要支持定义并决定页的大小，例如常见的4KB、2MB或4MB等。
页表：硬件需要支持存储和访问页表，以进行逻辑地址到物理地址的映射。页表是一个数据结构，用于存储每个页面的对应关系和其他控制信息。
3.存储器管理支持：硬件需要支持存储器管理，包括分配和回收内存页面的机制。这通常涉及到与主存储器（RAM）的交互，以加载和保存页面。

4.错误处理机制：在分页机制中，硬件需要支持错误处理机制，如页面错误（Page Fault）的检测、处理和中断通知。

分段存储管理

分段：

1.作业地址空间划分成若干段，每段定义了一组逻辑信息

2.每个段都有名字。为实现简单，常用段号代替段名（段号从0开始）

3.每个段内都从0开始编址，并采用一段连续的地址空间。由于分多个段，所以地址是二维的，亦即逻辑地址由段号S和段内地址W组成

具体结构如下：

段表：用于将逻辑地址映射到物理地址。

 地址变换机构

段页式存储管理方式

分页系统能有效地提高内存利用率，分段系统能很好地满足用户的需要，取二者之长，得到段页式存储管理方式

基本思想：将用户程序分成若干段，再把每段分成若干页，逻辑地址结构如下

地址变换机构

 有效访问时间（EAT）

定义：从进程发出指定逻辑地址的访问请求，经过地址变换，到在内存中找到对应的实际物理地址所需要花费的总时间

基本页式管理下EAT的计算

1、无快表

假设一次访问内存的时间为t, 则无快表情况下，EAT=t+t=2t

2、有快表

假设一次访问快表的时间为λ，快表命中率a，一次访问内存的时间为t 则EAT=a*λ+(1-a)*(λ+t)+t或EAT=a*(λ+t)+(1-a)*(λ+t+t)

例题

下列内存分配算法中，（     ）更易产生无法利用的小碎片

   A．单一连续分配

   B．固定分区分配

   C．可变分区分配

   D．页式分配

答案：D

段式和页式存储管理的地址结构很类似，但是它们有实质上的不同，以下错误的是（   ）

   A．页式的逻辑地址是连续的，段式的逻辑地址可以不连续

   B．页式的地址是一维的，段式的地址是二维的

   C．分页是操作系统进行的，分段是用户确定的

   D．页式采用静态重定位方式，段式采用动态重定位方式

答案：D（都是既可以静态又可以动态）

离散存储管理的主要特点是 (  ) 。

   A．不要求将作业装入到内存的连续区域

   B．不要求将作业同时全部装入到内存的连续区域

   C．不要求进行缺页中断处理

   D．不要求进行页面置换

答案：A

什么是逻辑地址、物理地址、地址重定位、实现地址重定位方法有哪几种？

逻辑地址是指从应用程序角度看到的内存单元，又称相对地址、虚地址

物理地址是指实际存储的单元编号，又称绝对地址、内存地址

地址重定位：把程序和数据的逻辑地址转换为相对地址的过程，分为静态重定位和动态重定位

前者是指在装入作业时就进行逻辑地址到物理地址的转换，后者是指在装入作业时先不转换，而是在作业执行过程中进行转换

什么是内部碎片和外部碎片？常见的内存分配技术中都会产生什么碎片？

内部碎片是指容量很小而且不能再被分配的内存区域，外部碎片是指容量很小但是还能被再分配的内存区域

产生内部碎片的分配方式：单一连续分配、固定分区分配、页式分配、段页式分配

产生外部碎片的分配方式：可变分区分配、段式分配

连续存储和离散存储的比较

连续存储是指给一个用户程序分配一个连续的内存空间，又称分区管理方式，包括可变分区、固定分区，离散存储是指给一个用户程序分配一个非连续的存储空间，包括页式、段式存储，前者内存管理简单，但内存利用率低，后者管理复杂，利用率高，使用用户程序的动态增长

虚拟存储器

解决内存容量不够问题的办法

从物理上扩充内存

从逻辑上扩充内存——虚拟存储器

局部性原理：CPU访问存储器时，无论是存取指令还是存取数据，所访问的存储单元都趋于聚集在一个较小的连续区域中

时间局部性（Temporal Locality）：如果一个信息项正在被访问，那么在近期它很可能还会被再次访问。
程序循环、堆栈等是产生时间局部性的原因。
空间局部性（Spatial Locality）：在最近的将来将用到的信息很可能与正在使用的信息在空间地上是临近的。（如数组）

虚拟存储器定义：具有请求调入功能和置换功能，能从逻辑上对内存容量加以扩充的一种存储系统

基本原理：1.部分装入2.请求调页3.页面置换

请求分页系统：在分页系统基础上，增加了请求调页功能和页面置换功能所形成的页式虚拟存储系统

硬件支持：1.请求分页的页表机制2.缺页中断机构3.地址变换机构

请求分段系统：在分段系统基础上，增加了请求调段功能和分段置换功能所形成的段式虚拟存储系统

硬件支持：1.请求分段的页表机制2.缺段中断机构3.地址变换机构

虚拟存储器特征：1.多次性2.对换性3.虚拟性（从逻辑上扩充内存，使用户看到的内存容量大于实际内存容量）

请求分页存储管理方式

页表表项

地址变换过程：

 从上图可以看到，当发生缺页中断时，首先保留CPU现场，从外存中找到缺页，在内存没满的情况之下，CPU从外存调入缺页，修改页表

缺页率：

在进程的运行过程中，访问页面成功的次数为S，访问页面失败的次数为F，缺页率f=F/(F+S)

页面置换算法

好的页面置换算法，应具有较低的页面更换频率

1.最佳置换算法（OPT）

选择未来最长时间内不再使用的页面淘汰

2.先进先出（FIFO）

选择在内存中驻留时间最长的页面淘汰

3.最近最久未使用置换算法 (LRU)

选择最近最久未使用的页面进行淘汰

 使用堆栈测量“最近未使用”

4.最少使用页面置换算法LFU

5.最近没使用页面置换算法NRU

6.时钟策略

通俗解释：蓝色页号代表的是指针此时指向的页号，刚开始指向最早放入的页号，当物理块满（7 0 1）且需要页面置换时，指针将把所指向的页面星号去掉，循环扫描（扫描过程中如果指向的页号有星号，就去星号，否则就淘汰）直到再扫描到7（次吃7 0 1都没星号了），淘汰7，放入2*淘汰之后注意指针前移一位（指向0），当新来的页号存在于物理块中时，指针不移动，且将此页号加星（无论在什么位置，但是如果原来就有星，那就不改变）。接下来来3，消除0上的星，指向1,1没有星，淘汰，放入3，指针前移，后续重复此步骤即可，不明白的可以在评论区问或者私信。

7.改进时钟策略

除了有访问位A外，还增加一个修改位M。 由访问位A与修改位M可以组成下面4种类型的页面： 1类(A=0,M=0)，是最佳淘汰页； 2类(A=0,M=1) ； 3类(A=1,M=0) ； 4类(A=1,M=1) :最近被访问且被修改过的页，最不应该淘汰

步骤：

(1)从指针当前位置开始，扫描循环队列，寻找A=0且M=0的第1类页面，将所遇到的第一个页面淘汰。 (2)若第1步查找一周后未遇到第1类页面，则寻找A=0且M=1的第2类页面，将所遇到的第一个页面淘汰。第2轮扫描中将所有扫描过的页面的访问位A清0。 (3)若第2轮扫描失败，则返回(1)，若仍失败，再重复第(2)步，此时就一定能找到被淘汰的页

抖动

若一个进程频繁地进行页面调入调出，使系统效率降低，通常称这种现象为该进程发生了抖动

产生抖动原因：

1.系统内的进程数太多，致使一个进程分得的内存块过少

2.系统采用的页面置换算法不合理

一个进程在时刻t-△t到时刻t之间所访问的页面的集合称为该进程在时刻t的工作集 ，用W(t, △t)表示。变量△t称为“工作集窗口尺寸”，记为|W(t, △t )|

预防抖动的方法：

1.采取局部置换策略

2.处理机调度中引入工作集算法

3.暂停某些进程

请求分页系统有效访问时间（EAT）计算

1.页在内存，且快表检索命中

EAT= 访问快表时间+访问内存时间

2.页在内存，但快表检索没有命中

EAT= 访问快表时间+访问页表时间+更新快表时间+访问内存时间

3.页面不在内存

EAT=访问快表时间+访问页表时间+缺页中断处理时间+更新快表时间+访问内存时间

4.加入概率的综合公式(a是快表命中率，f是缺页率，λ是访问快表/更新快表时间，t是访问内存/页表的时间，ε是缺页中断处理时间)

EAT= λ +at +(1-a){t + f*(ε+λ+t) +(1-f)*(λ+ t) }

请求分段存储管理方式

在请求分段系统中，程序运行之前，只需调入若干分段（不必调入所有分段），便可启动运行。 当所访问的段不在内存时，可请求OS将所缺的段调入内存。 像请求分页系统一样，为实现请求分段存储管理功能，同样需要一定的硬件支持和相应的软件

段表表项

 地址变换

缺段中断机构

缺段中断的处理比缺页中断复杂（段不是定长）

例题

分页式存储管理的主要特点是（ ） 。

    A、要求处理缺页中断   

    B、要求扩充主存容量

    C、不要求作业装入到主存的连续区域

    D、不要求作业全部同时装人主存

答案：C

在存储管理中， 采用覆盖与交换技术的目的是（ ）。

    A、节省主存空间         B、物理上扩充主存容量

    C、提高 CPU 的效率      D、实现主存共享

答案：A

工作集/驻留集模型可用来解决缺页率高的问题，缺页率高对系统会造成（    )情况？除采用工作集/驻留集模型，还可通过（  ）、（  ）、（   ）预防该问题的产生

抖动，L=S准则（L：缺页之间平均服务时间，S：平均缺页服务时间），暂停某些进程，局部置换

请求分页存储管理系统，如果被访问页在内存，则满足一次内存访问请求需要200ns；如果被访问页不在内存，如果系统有空闲页框或被置换出的页未修改，则满足一个访问请求需要7ms；如果被换出的页已被修改，则需要15ms。 假设系统缺页率为5%，并且被换出的页有60%被修改，求有效访问时间。(设系统只运行一个进程且交换时CPU空闲)

EAT=95%*（200ns+200ns）ns+5%*（200ns+60%*15ms+40%*7ms+200ns)

解释：在概率为0.95情况下，不发生缺页，此时只需访问一次页表和内存即可。1-0.95的概率下，除了访问这两个部分还需要多加一个7和15ms

此题没涉及快表，同时在缺页处理的说明上比较含蓄，但其本质不变

请求分页管理系统中，假设某进程的页表内容如下表所示。

页表内容

页号	页框（Page Frame）号	有效位（存在位）
0	101H	1
1	—	0
2	254H	1

   页面大小为4KB，一次内存的访问时间是100ns，一次快表（TLB）的访问时间是10ns，处理一次缺页的平均时间为108ns（已含更新TLB和页表的时间），进程的驻留集大小固定为2，采用最近最少使用置换算法（LRU）和局部淘汰策略。假设①TLB初始为空；②地址转换时先访问TLB，若TLB未命中，再访问页表（忽略访问页表之后的TLB更新时间）；③有效位为0表示页面不在内存，产生缺页中断，缺页中断处理后，返回到产生缺页中断的指令处重新执行。

设有虚地址访问序列2362H、1565H、25A5H，请问：

（1）依次访问上述三个虚地址，各需多少时间？给出计算过程。

（2）基于上述访问序列，虚地址1565H的物理地址是多少？请说明理由。

比较简单，直接放答案：1.210ns 318ns 110ns  2.  101565H

有问题可以在评论区或私信提问

如果虚拟存储是在段页式存储管理的基础上进行实现，需要补充哪些工作？说说你的思路

1.页面置换算法：在段页式存储管理中，每个段被分成若干页，而页是虚拟存储的基本单位。因此，需要选择适当的页面置换算法来决定在内存中哪些页面应该被替换出去，以便为新的页面腾出空间。常见的页面置换算法包括最佳页面置换算法（OPT）、最近未使用（LRU）、先进先出（FIFO）等

2.缺页中断处理：当发生缺页中断，需要进行相应的处理，执行页面调度算法从外存中加载页面到可用的物理页面，更新页表和段表相关数据结构，确保虚拟地址到物理地址的正确映射。

·文件管理

文件和文件系统

数据项（Data Item）：数据项是操作系统中最基本的数据单位，它可以是一个字节、一个字符或一个固定长度的数据块。数据项可以包含不同类型的数据，如整数、浮点数、字符串等。

记录（Record）：记录是由多个数据项组成的数据集合。它是在逻辑上相关联的数据项的集合，表示某个实体或事物的完整信息。例如，对于一个学生记录，包含学生的姓名、学号、年龄等多个数据项。

关键字（Key）：关键字是记录中用于标识、检索和区分各个记录的特定数据项。通常，关键字是具有唯一性的，用于在数据库中进行记录的定位和索引。例如，在学生记录中，学号可以作为关键字。

文件（File）：文件是指存储在辅助存储设备（如硬盘、磁带等）上的命名数据集合。文件是数据的逻辑单位，它可以包含多个记录。通过文件，操作系统可以方便地组织、存储和管理大量的数据。

有结构文件（Structured File）：有结构文件是指按照特定的组织结构和格式进行存储的文件。其中的数据项、记录和字段有固定的结构和关系，可以根据预定义的规则进行访问和操作。例如，关系型数据库中的表就是一种有结构文件。

无结构文件（Unstructured File）：无结构文件是指没有固定格式和组织结构的文件。它们可以包含任意类型的数据，如文本、图像、音频等。无结构文件的访问和操作通常需要依赖特定的应用程序或格式解析器。

文件系统是操作系统中用于组织和管理文件的一种方法和结构

文件系统由三部分组成：文件系统的接口，对对象操纵和管理的软件集合（核心），对象及属性

文件的类型：

按用途分：系统文件、用户文件、库文件

按文件中数据的形式分：源文件、目标文件、可执行文件

按存取控制属性分：执行文件、读文件、写文件

文件的操作：

1.创建文件：系统为新文件分配外存空间、在文件目录中为其建立目录项

2.删除文件：回收外存空间、找到并删除目录项

3.读文件：在系统调用中给出文件名和读入的内存地址，需要先找到指定的目录项，得到文件的外存地址和读指针

4.写文件：在系统调用中给出文件名和文件在内存的地址，找到目录项，利用写指针进行读操作

5.打开文件：系统将指明文件的属性从外存拷贝到内存打开文件表的一个表目中，并将该表目的索引号返回给用户

6.关闭文件：OS将会从打开文件表中把该文件对应的表目删除，对应的存储空间标为可分配

文件的结构

逻辑结构（文件组织）：从用户观点出发所观察到的文件组织形式，是用户可以直接处理的数据及其结构

物理结构：文件的存储结构，是指文件在外存上的存储组织形式。

文件的逻辑结构类型：

按有无结构分：有结构文件、无结构文件

按文件的组织方式分：顺序文件、索引文件、顺序索引文件

有结构文件：

每个记录都是描述实体集中的一个实体，各记录着相同或不同数目的数据项

无结构文件：源程序、可执行文件、库函数等，采用的是无结构文件形式，即流式文件。 其长度以字节为单位

顺序文件：一系列记录按某种顺序排列所形成的文件

索引文件：为文件建立一张索引表，并为每个记录设置一个表项，以加快对记录的检索速度

索引顺序文件：为文件建立一张索引表，为每一组记录中的第一个记录设置一个表项。综合前两者优势

文件目录

目的：1.实现“按名存取”2.文件共享3.允许文件重名

文件控制块FCB：用于描述和控制文件的数据结构

文件目录：文件控制块的有序集合

一个FCB为目录文件的一个目录项，主要内容：文件名、文件物理地址、建立日期、文件上一次修改日期等

索引节点（i节点）：采用文件名与文件描述信息分开的方法，将文件描述信息单独形成的一个数据结构

目录项仅由文件名和指向该文件所对应的i节点的数据结构

目录结构：

单级目录结构

 缺点：查找速度慢、不允许重名、不益于实现文件共享

两级目录结构

分为用户文件目录UFD（User File Directory）主文件目录MFD（Master File Directory）

不同用户可以使用不同的文件名来访问系统中的同一个共享文件

多级目录结构

目录查询

1.顺序检索法：

对单级目录：根据用户提供的文件名，用顺序查找法直接从文件目录中找到指定文件的目录项。 对树型目录：须对多级目录进行查找。（如果在顺序查询中，发现有文件分量名未找到，则应停止查找，并返回“文件未找到”信息。）

例题：某文件系统的目录结构如下图所示，已知每个目录项占256B，磁盘的一块为512B。设当前目录为根目录。 （1）查询文件Wang的路径是什么？ （2）系统需要读取几个文件后才能查到Wang？ （3）计算系统找到Wang，至少读了几个盘块。 （4）给出一种加速文件查找速度的目录结构。

1./D/DC/DDC/Wang

2.三个，分别是D、DC、DDC

3.因1个盘块中可存储2个目录项，读取根目录的第2个盘块时才能找到文件D的目录项;读取文件D的第2个盘块时才能找到DC的FCB;读取文件DC的第2个盘块时才找到文件 DDC的 FCB;读取DDC的第1个盘块就能找到Wang。因此，系统找到Wang，至少读了7个盘块。

4.可以采用类似 UNIX的方法，缩短目录项，例如，目录项中仅包含文件名(12个字节)和索引节点号(4个字节)，目录项长度为16字节，这样每个盘块可存放32个目录项。这样只需读4个盘块就可找到Wang。

2.Hash检索法

建立一张Hash索引文件目录，系统利用用户提供的文件名并将它转变为文件目录的索引值，再利用该索引值到目录中去查找

处理“冲突”的规则：用Hash法查找目录时，若相应的目录项是空的，则表示系统中无此文件； 若目录项中的文件名与指定文件名匹配，则表示已找到该文件，故可从中找到该文件的物理地址； 目录项中的文件名与指定文件名不匹配，则发生了“冲突”，此时须将其Hash值再加上一个常数（应与目录长度值互质），形成新的索引值。再返回第一步重新开始查找。 di=(di-1+p)%m  (p与m互质，d0=H(k)

外存分配方式

1.连续分配方式

为每一个文件（此时叫顺序文件）分配一组相邻的盘块，会形成磁盘碎片(外部碎片)，可以用紧凑方法消除碎片，但将花费比内存紧凑多得多的时间

优点：访问操作容易、顺序访问速度快、磁头移动的距离最少

缺点：要求有连续的存储空间、必须事先知道文件的大小、会形成磁盘碎片、不能灵活地删除和插入记录、文件大小不宜动态变化

2.链接分配方式

通过在每个盘块上的链接指针，将同属于一个文件的多个离散的盘块链接成一个链表，这样形成的物理文件称为链接文件

优点：消除了外部碎片，提高了外存利用率，便于文件动态增长， 文件的增、删、改也十分方便

分为隐式链接和显式链接

隐式链接：

每个文件的目录项FCB中，包含第一个盘块和最后一个盘块号（指针） 在每个盘块中，都有一个指向下一个盘块的指针

缺点：不利于随机访问、可靠性差、增大内部碎片

显式链接：用于链接文件物理块的指针（块号），显式地存放在外存的一张链接表中，整个磁盘仅一张表

 3.索引分配方式

为每个文件分配一个索引块（表），把分配给该文件的盘块号都记录在索引块中

优点：支持直接访问、不会产生内部碎片

缺点：每个文件都要一个索引表，小文件仍需分配一个盘块

分为：单级索引、多级索引、混合索引

混合索引：

举例；设文件索引节点中有7个地址项，其中4个地址项是直接地址索引，2个地址项是一级间接地址索引，1个地址项是二级间接地址索引，每个地址项大小为4字节。若磁盘索引块和磁盘数据块大小均为256字节，则可表示的单个文件最大长度是？

直接地址寻址空间：256B*4=1KB

一级索引寻址空间：256/4*2*256=32KB

二级索引寻址空间：256/4*256/4*256*1=1024KB

总共1057KB

文件存储空间管理

1.空闲表法和空闲链表法

2.位示图法

	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	1	1	0	0	0	1	1	0	0	1	0	0	1	1	0	0
1	1	0	0	1	1	1	1	1	1	0	0	0	1	1	1	0
2	0	0	0	0	1	1	1	1	1	0	0	0	0	1	1	0
3	1	1	0	0	0	1	1	0	1	0	0	0	0	0	0	1
…

 用1代表已分配、0代表空闲

位示图盘块分配：

顺序扫描位示图，从中找出值为“0”的二进制位。 转换成相应的盘块号。 设行号为i，列号为j，则对应的盘块号b为： b = (i-1)×n + j   n为每行的位数，修改位示图，令map[i][j]=1

位示图盘块内存回收：

将回收盘块号转换成位示图的行号和列号。 i = (b-1) / n+1 j = (b-1)/n+1 修改位示图，令map[i][j]=0

3.成组链接法

分配空闲盘块过程：

查空闲盘块数N（比如上图中，空闲盘块号栈的空闲盘块数为100）

如果N>1

从S.free（N-1）中取出空闲块号（上图中即S.free(99)块号位201）； 把该块分配给申请者； N = N – 1

如果N=1

从S.free（0）中取出空闲块号； 其值=0，无空闲块，申请者等待； 其值≠0，把该块内容复制到空闲块号栈中，该块分配给申请者

回收空闲盘块过程：

查空闲块数N

如果N < 100（假设一组盘块数量为100）

N = N + 1； 回收的盘块号填入S.free（N-1）中

如果N = 100

把空闲块号栈内容写入回收块中； 把回收盘块号写入S.free（0）中； 空闲块号栈的S.free（N）单元中写入1

文件共享与文件保护

基于索引节点的文件共享（硬链接）

在基于索引节点的文件共享方式中，多个文件名可以指向同一个索引节点，从而实现文件的共享。这意味着对于共享文件的修改和访问会在所有指向该索引节点的文件名上生效。

问题：当多个用户共享一个文件时，文件所有者删除了该文件，也就是删除了该文件的索引结点，那么其他用户指向该索引节点的指针就会悬空

优点：实现简单、访问速度快

缺点：只能用于单文件系统不能跨文件系统

 基于符号链的文件共享

为了使用户b共享用户a的文件F，由操作系统创建一个LINK类型的新文件，也叫F，它被写入到用户b的目录中，以实现用户b的目录与文件F的链接。同名新文件只包含F的路径名。这样的链接方法叫符号链接（软链接）

只有文件的所有者才拥有指向其索引节点的指针，而共享该文件的其他用户只有该文件的路径名，并不拥有指向其索引节点的指针。这样就避免了指针悬空的问题。

软链接克服了硬链接的不足，没有任何文件系统的限制，任何用户可以创建指向目录的符号链接。因而现在更为广泛使用，它具有更大的灵活性，甚至可以跨越不同机器、不同网络对文件进行链接

 

优点：能链接计算机网络中不同计算机中的文件

缺点：扫描文件路径的开销大；需额外的空间存储路径

文件保护：

访问控制矩阵

访问控制矩阵以一个二维矩阵来进行存取控制，二维矩阵的一维的所有的用户，另一维是所有的文件，对应的矩阵元素则是用户对文件的存取权限，包括读（R）、写（W）、执行（E）

虽然在概念上很简单，但是当文件和用户较多时，访问控制矩阵将变得非常庞大，这无论是在内存空间上还是在对矩阵扫描的时间开销上都是不合适的。

存取控制表

存取控制表以文件为单位，把用户按某种关系划分为若干组，同时规定每组的存取权限，这样所有用户组对文件权限的集合就形成了该文件的存取控制表，每个文件都有一张存取控制表，在实现时，该表存放在文件说明中。文件被打开时，由于存取控制表也相应地被复制到了内存活动文件中，因此存取控制验证能高效进行。

题目补充：

设文件F1当前引用计数值为1，先建立F1的符号链接(软链接)文件F2，再建立F1的硬软链接文件F3，然后删除F1。此时，F2和F3的引用计数值分别是__________。1,1

下列文件物理结构中，适合随机访问且易于文件扩展的是__________ A．连续结构 B．索引结构 C．链式结构且磁盘块定长 D．链式结构且磁盘块变长    B

设置当前工作目录的主要目的是：加快文件检索速度

存放在某个磁盘上的文件系统，采用混合索引分配方式，其FCB中共有13个地址项，第0~9个地址项为直接地址，第10个地址项为一次间接地址，第11个地址项为二次间接地址，第12个地址项为三次间接地址。如果每个盘块的大小为512字节，若盘块号需要用3个字节来描述，而每个盘块最多存放170个盘块地址：

（1）该文件系统允许文件的最大长度是多少？

（2）将文件的字节偏移量5000、15000转换为物理块号和块内偏移量。

（3）假设文件的FCB已在内存，为了访问文件中某个位置的内容，最少需要访问几次磁盘，最多需要访问几次磁盘？

（4）对某个长度为18000000字节的文件，它需要占用多少个盘块（包括间接地址块）？

1.(10+170+170*170+170*170*170）*512=4942080*512字节=2471040KB
2.5000/512得到商为9，余数为392，所以字节偏移量5000对应的逻辑块号为9，块内偏移量为392   15000/512得到商为29，余数为152，即字节偏移量15000对应的逻辑块号为29，块内偏移量为152。由于10<29<10+170，而29-10=19，故可从FCB的10号地址项，即一次间址项中得到一次间址的地址；并从一次间址块的19号（即该块的第57~59这3个字节）中获得对应的物理盘块号，块内偏移量为152
3.  1次、4次
4.  18000000/512＝35156.25，因此该文件总共需要35157个盘块存储  但是这仅仅是数据盘块，还需要讨论其间接盘块，由于10＋170＋170×170<35157<10＋170＋170×170＋170*170*170，故该文件不仅需要使用10个直接地址项，还需要使用一次、二次及三次间接地址项。又因为35157－（10＋170＋170×170）＝6077，6077/（170×170）得到商为0，余数为6077，得知该文件在三次间接地址时还需要1个二次间接地址块；而余数6077/170得到商为35余数为127，可知该文件在三次间接地址时还需要36个一次间接地址块。因此该文件需要：
直接地址  10个数据盘块
一次地址 1个一次地址块，170个数据块
二次地址 1个二次地址块+170个一次地址块+170*170个数据块
三次地址 1个三次地址块+1个二次地址块+36个一次地址块+（35*170+127）（或直接6077）

某文件系统为一级目录结构，文件的数据一次性写入磁盘，已写入的文件不可修改和删除，但可以多次创建新文件，请回答下列问题：

（1）在连续、链式、索引三种文件的数据块组织形式中，那种更适合？请说明理由

（2）为定位文件数据块，需要在FCB中设计哪些相关描述字段？

（3）为快速找到文件，FCB是集中存储好还是与对应的文件数据块连续存储好？请说明理由

（1）因为文件一旦创建只能读取不能改写，采用连续存储方式，磁盘寻道时间更短，磁盘存储效率更高。
（2）在FCB中加入的字段为：<起始块号、块数>或<起始块号、结束块号>.
（3）FCB集中存储好，在随机查找文件名时，只需访问FCB对应的块，减少磁头移动和磁盘I/O访问次数。

请比较内存的分页存储管理技术和文件的索引外存分配方式在思想和相应的数据结构有何异同？

不同：应用范围不同：分页存储管理技术主要应用于操作系统的内存管理中，而索引外存分配方式主要应用于文件系统的文件存储管理中

相同：两种方法思想上接近的，都采用离散的存储方式，都是将逻辑空间和物理空间分成等大小的若干块，所需要的数据结构主要功能都是完成逻辑块到物理块的映射

·设备管理

I/O系统

I/O系统：用于实现数据的输入、输出及数据存储的系统

I/O系统设备类型：

按输入输出特征分：输入型设备、输出型设备、存储型设备

按信息交换单位分：块设备、字符设备

按共享属性分：独占设备、共享设备、虚拟设备

按传输速率分：低速设备、中速设备、高速设备

I/O设备组成：机械部件和电子部件（设备控制器）

I/O设备子系统包括：直接用于I/O和存储数据的设备，设备控制器和高速总线，I/O通道

通常设备并不直接与CPU通信，而是与设备控制器通信，故设备和设备控制器间应有接口

该接口中包含3类信号：数据信号、控制信号、状态信号

设备控制器：是CPU和I/O设备之间的接口，控制一个或几个I/O设备，实现I/O设备和计算机之间数据交换

设备控制器是可编址设备： 控制一个设备时，有唯一的设备地址； 连接多个设备时，则含有多个设备地址

设备控制器功能：数据交换、数据缓冲、地址识别

设备控制器组成：CPU与设备控制器的接口、设备与设备控制器的接口、I/O逻辑

I/O通道：具有执行I/O指令的能力的一种特殊的处理机，与CPU共享内存，分担CPU任务

I/O控制方式

1.程序I/O方式

CPU从设备控制器的状态寄存器中查询设备是否可用，如果不可用就一直轮询查询，直到可用为止

造成CPU忙等，极大浪费

2.中断驱动方式

当CPU请求IO时，就直接发送IO读取的相关命令。如果当前设备正被占用，就排队，然后IO设备器会对依次对队列中的进行处理，处理完成后就发出中断命令，打断CPU原本的操作，转而去执行中断程序

优点：在IO的时候，CPU可以处理其他线程的工作，CPU的利用效率提高了

缺点：在IO完成后，还是需要CPU将数据转移到内存中，还是会占用一定的CPU

3.DMA（直接存储器访问）

DMA可以直接与内存相连，也就是说IO设备可以直接与内存交换数据，不要CPU的中转了

优点： CPU只需要在开始的时候，指定从内存和IO设备中的哪些位置进行读写，进一步增加了CPU的利用率

缺点： DMA可以一次性读取多个块，但是在内存和IO设备中必须是连续的

 

4.通道控制方式

通道可以执行IO指令，CPU只需要将相关的IO指令发送给通道控制器就可以了，通道会执行IO指令，完成对应的传输

相较于DMA，通道拥有着自己的指令和程序，具有更强的IO处理能力

缓冲管理

引入缓冲原因：

1.为了缓和CPU与I/O设备速度不匹配的矛盾

2.减少对CPU的中断频率

3.提高CPU和I/O设备的并行性

单缓冲：

T：从磁盘把一块数据输入到缓冲区的时间

M：操作系统将该缓冲区数据送到用户区的时间

C：CPU对这块数据处理（计算）时间

 由于T和C是可以并行的，故系统处理一块数据的时间可表示为 Max(T, C) + M

双缓冲：在设备输入时，先将数据送入第一个缓冲区，装满后便转向第二个缓冲区。此时操作系统可以从第一个缓冲区移出数据并送入用户进程，接着CPU对数据进行计算

若C

若C>T，系统处理一块数据的平均时间大约为C+M，可使进程不必等待设备（CPU可以不停地计算）

例题：某文件占10个磁盘块，现要把该文件磁盘块逐个读入主存缓冲区，并送用户区进行分析。假设一个缓冲区与一个磁盘块大小相同，把一个磁盘块读入缓冲区的时间为100µs，将缓冲区的数据传送到用户区的时间是50µs，CPU对一块数据进行分析的时间为50µs。在单缓冲区和双缓冲区结构下，读入并分析该文件的时间分别是（）（）

单缓冲(Max(C,T)+M)*10+C=1550             双缓冲 Max（T，C+M)*10+(C+M)=1100

循环缓冲

循环缓冲的组成
缓冲区：缓冲区大小相同，分为三种类型:用于装入输入数据的空缓冲区R、已装满数据的缓冲区G、现行工作区C
指针：用于指示计算进程下一个可用缓冲区G的指针nextg、指示输入进程下次可用的空缓冲区nexti、指示计算进程正在使用的缓冲区C的指针current

循环缓冲区的两个过程

1.Getbuf过程

计算进程要使用缓冲区时，调用Getbuf过程：将Nextg所指的缓冲区改为“现行”，用Current指向它，同时将Nextg指向下一个满缓冲区G

输入进程要使用缓冲区时，调用Getbuf过程：将Nexti所指的缓冲区供给输入进程使用，同时将Nexti指向下一个空缓冲区R

2.Releasebuf过程 

计算进程把C缓冲区的数据提取完毕时，调用Releasebuf过程，将缓冲区G释放：将该缓冲区由现行缓冲区C改为空缓冲区R

输入进程把缓冲区装满时，调用Releasebuf过程，将该缓冲区释放，并改为满缓冲区G

缓冲池

组成：

1.空缓冲队列emq：空缓冲区链成的队列

2.输入队列inq：装满输入数据的缓冲区链成的队列

3.输出队列outq：装满输出数据的缓冲区链成的队列

4.用于收容输入数据的工作缓冲区bin

5.用于提取输入数据的工作缓冲区sin

6.用于收容输出数据的工作缓冲区bout

7.用于提取输出数据的工作缓冲区sout 

缓冲池四种工作方式：收容输入、提取输入、收容输出、提取输出

收容输入：输入进程请求输入数据，从空缓冲队列中取出一块作为收容输入数据的工作缓冲区，冲满数据后将缓冲区挂到输入队列队尾

提取输入：计算进程想要取得一块输入数据，从输入队列中取得一块冲满输入数据的换乘功能区作为提取输入数据的工作缓冲区，缓冲区读空后挂到空缓冲区队列

收容输出：计算进程想要将准备好的数据冲入缓冲区，从空缓冲队列中取出一块作为“收容输出数据的工作缓冲区”，数据冲满之后，将缓冲区挂到输出队列队尾

提取输出：从输出队列中取得一块冲满输出数据的缓冲区作为“提取输出数据的工作缓冲区“，缓冲区读空后挂到空缓冲队列

设备分配

为防止诸进程对系统资源的无序竞争，规定设备不允许用户自行使用，必须由系统统一分配

设备分配中的数据结构：设备控制表、控制器控制表、通道控制表、系统设备表

设备分配应该考虑的因素：

1.设备的固有属性：设备是虚拟设备、共享设备，还是独占设备？

2.设备分配算法：先来先服务、优先级高者优先...

3.安全性：安全分配方式——进程提出I/O请求后即阻塞，使该进程不可能再请求任何资源，在运行时又不保持任何资源，摒弃“请求和保持”条件     缺点：串行工作，进程进展缓慢 不安全分配方式——发出I/O请求后仍继续运行，仅当进程所请求的设备已被另外一个进程占用，请求进程才阻塞。——具有“请求和保持”条件，有可能死锁

脱机技术：批处理阶段引入了脱机输入/输出技术（用磁带完成），在外围控制机的控制之下，慢速输入设备的数据先被输入到更快速的磁带上，之后主机可以从快速的磁带上读入数据，缓解了速度矛盾，外围控制机控制了磁带进行输入输出，脱离了主机的控制

Spooling技术（假脱机技术，用软件方式模拟脱机技术）

 “井”模拟磁带，输入进程和输出进程模拟脱机输入时的外围控制机

为了缓和CPU的高速性与I/O设备低速性间的矛盾而引入了脱机输入、 脱机输出技术。 当系统中引入了多道程序技术后，利用其中的一道程序，来模拟脱机输入时的外围控制机功能，用另一道程序来模拟脱机输出时外围控制机的功能， 便可在主机的直接控制下，实现脱机输入、 输出功能。 此时的外围操作与CPU对数据的处理同时进行。这种联机情况下实现的同时外围操作称为Spooling技术，又称假脱机操作

案列----共享打印机

回顾：独占式设备----只运行各个进程串行使用的设备，共享设备----允许多个进程“同时使用”设备（宏观同时，微观可能交替）

当用户进程请求打印输出时，SPOOLing系统同意为它打印输出，但并不真正立即把打印机分配给该用户进程，而是： Step1： 由输出进程在输出井中为之申请一个空闲磁盘块区，并将要打印的数据送入其中； Step2：输出进程再为用户进程申请一张空白的用户请求打印表，并将用户的打印要求填入其中，再将该表挂到请求打印队列上。 如果还有进程要求打印输出，系统仍可接受该请求，也同样为该进程做上述两件事

Spooling技术特点：提高了I/O速度、将独占设备改造成共享设备、实现了虚拟设备功能

I/O软件系统层次模型

当一个用户进程试图从文件中读一个数据块时，需要通过系统调用以取得操作系统的服务来完成。 设备独立性软件接收到请求后，首先在高速缓存中查找相应的页面，如果没有，则调用设备驱动程序向硬件发出一个请求，并由驱动程序负责从磁盘读取目标数据块。 当磁盘操作完成后，由硬件产生一个中断，并转入中断处理程序，唤醒用户进程以及结束此次I/O请求，继续用户进程的运行

中断处理程序步骤：

1.测定是否有未响应的中断信号

2.保护被中断进程的CPU环境

3.转入相应的设备处理程序

4.中断处理

5.恢复被中断进程CPU的现场并退出中断

设备驱动程序

设备驱动程序又称为设备处理程序，它是I/O进程与设备控制器之间的通信程序

功能：

1.接收由独立性软件发来的命令和参数，并将命令中的抽象要求转换为具体要求

2.发出I/O命令

3.检查用户I/O请求的合法性、了解I/O设备状态

设备独立性软件

概念：指应用程序中所使用的设备，不局限于使用某个具体的物理设备

为了实现设备独立性，必须再在驱动程序之上设置一层软件，称为设备独立性软件。其基本功能是执行对所有设备公共的I/O功能，并且向用户层软件提供一个统一的接口

优势：1.设备分配时的灵活性 2.易于实现I/O重定向

磁盘存储器管理

磁盘设备可包括一或多个物理盘片，每个盘片分一个或两个存储面，如图6-23所示。每个盘面组织成若干个同心环称为磁道，每个磁道划分成若干扇区。

磁盘调度

1.先来先服务（FCFS）

若递交给磁盘驱动程序的磁盘柱面请求按到达时间顺序分别是55、58、39、18、90、160、150、38、184，设磁头初始处于100柱面，则对于FCFS算法，平均寻道长度为多少？

服务顺序为：55, 58, 39, 18, 90, 160, 150, 38, 184 总寻道长度=45+3+19+21+72+70+10+112+146=498 平均寻道长度=498/9=55.3

2.最短寻道时间优先（SSTF）、

若递交给磁盘驱动程序的磁盘柱面请求按到达时间顺序分别是55、58、39、18、90、160、150、38、184，设磁头初始处于100柱面，则对于SSTF算法，平均寻道长度为多少？

服务顺序：90, 58, 55, 39, 38, 18, 150, 160, 184 总寻道长度=10+32+3+16+1+20+132+10+24=248 平均寻道长度=248/9=27.56  有饿死现象

3.扫描(SCAN)算法

若递交给磁盘驱动程序的磁盘柱面请求按到达时间顺序分别是55、58、39、18、90、160、150、38、184，设磁头初始处于100柱面，若采用SCAN算法，平均寻道长度为多少？

设开始时向磁道号增加方向访问： 服务顺序：150, 160, 184, 90, 58, 55, 39, 38, 18 总寻道长度=50+10+24+94+32+3+16+1+20=250 平均寻道长度=250/9=27.78

设开始时向磁道号减小方向访问： 服务顺序：90, 58, 55, 39, 38, 18, 150, 160, 184 总寻道长度=10+32+3+16+1+20+132+10+24=248 平均寻道长度=248/9=27.56

4. 循环扫描(CSCAN)算法

若递交给磁盘驱动程序的磁盘柱面请求按到达时间顺序分别是55、58、39、18、90、160、150、38、184，设磁头初始处于100柱面，若采用CSCAN算法，平均寻道长度为多少？ 

设开始时向磁道号增加方向访问： 服务顺序：150, 160, 184, 18, 38, 39, 55, 58, 90 总寻道长度=50+10+24+166+20+1+16+3+32=322 平均寻道长度=322/9=35.78

例题

为什么要引入设备独立性？如何实现设备独立性？

设备独立性是指应用程序独立于某些具体的物理设备

目的：提高系统的可适应性和可拓展性，方便用户编程

实现：在设备驱动程序上面添加设备独立性软件，执行所有设备的公有操作，使用数据结构--逻辑设备表

试说明Spooling系统的组成

输入井和输出井：在磁盘上开辟的两个大的存储空间。输入井模拟脱机输入时的磁盘
输入缓冲区和输出缓冲区：在内存中开辟的两个缓冲区，输入缓冲区用于暂存由输入设备送来的数据，再传送到输入井。输出缓冲区用于暂存从输出井送来的数据，再传送给输出设备
输入进程： 模拟脱机输入时的外围控制机
输出进程 ：进程模拟脱机输出时的外围控制机

设备驱动程序通常完成哪些工作？

接收由独立性软件发来的命令和参数，并将命令中的抽象要求转换为具体要求
发出I/O命令。如果设备空闲，便立即启动I/O设备去完成指定的I/O操作
及时响应由控制器或通道来的中断请求
检查用户I/O请求的合法性、了解I/O设备状态