计算机操作系统原理复习大全

名词解释

计算机系统的层次结构

?

硬件层 ?

操作系统层 ?

支撑软件层 ? 应用软件层

?

操作系统

操作系统是管理系统资源、控制程序执行，改善人机界面，提供各种服务，

合理组织计算机工作流程和为用户有效使用计算机提供良好运行环境的最基本的一种系统软件。

管理

处理器管理

主要是对中央处理机 (CPU) 进行动态管理。

为了提高CPU 的利用率，采用多道程序设计技术(multiprogramming)。当多道程序并发(erupt simultaneously) 运行时, 引进进程的概念(将一个程序分为多个处理模块，进程是程序运行的动态过程)。通过进程管理，协调(coordinate)多道程序之间的CPU 分配调度、冲突处理及资源回收等

关系。

●存储管理

是对存储“空间”的管理，主要指对内存资源的管理。存储管理就是要根据用户程序的要求为用户分配主存储区域。

(1)主存分配；

(2)地址转换与存储保护；

(3)主存共享；

(4)存储扩充。

●设备管理

是对硬件设备的管理，其中包括对输入输出设备的分配、启动、完成和回收。负责管理计算机系统中除了中央处理机和主存储器以外的其它硬件资源

●文件管理

将逻辑上有完整意义的信息资源（程序和数据）以文件的形式存放在外存储器（磁盘、磁带）上的，并赋予一个名字，称为文件。是操作系统对计算机系统中软件资源的管理

并发性

?从宏观上看，并发性反映一个时间段中几个进程都在同一处理器上，处于运行还未运行结束状态。

?从微观上看，任一时刻仅有一个进程在处理器上运行。

并发进程分类：无关的，交往的。

（1）无关的并发进程

?无关的并发进程：一组并发进程分别在不同的变量集合上操作，一个进程的执行与其他并发进程的进展无关。

?并发进程的无关性是进程的执行与时间无关的一个充分条件，又称为Bernstein条件。

Bernstein条件

R(pi)={a1,a2,…an}，程序pi在执行期间引用的变量集

W(pi)={b1,b2,…bm}，程序pi在执行期间改变的变量集

若两个程序的变量集交集之和为空集：

R(p1)∩W(p2)∪R(p2)∩W(p1)∪W(p1)∩W(p2)={ }

则并发进程的执行与时间无关。

例如，有如下四条语句：

S1: a := x + y S2: b := z + 1

S3: c := a – b S4: w := c + 1

于是有：R(S1)={x,y} ,R(S2)={z}，R(S3)={a,b}，R(S4)={c}；W(S1)={a}, W(S2)={b}，W(S3)={c}，W(S4)={w}。

S1和S2可并发执行，满足Bernstein条件。其他语句并发执行可能会产生与时间有关的错误。

（2）交往的并发进程

?交往的并发进程：一组并发进程共享某些变量，一个进程的执行可能影响其他并发进程的结果。

与时间有关的错误

?对于一组交往的并发进程，执行的相对速度无法相互控制，各种与时间有关的错误

就可能出现。

?与时间有关错误的表现形式：

–结果不唯一

–永远等待

1.飞机票售票问题（结果不唯一）

void T1( ) {

{按旅客订票要求找到Aj};

int X1=Aj;

if(X1>=1) {

X1--;

Aj=X1;

{输出一张票};

} else

{输出信息"票已售完"};

}

void T2( ) {

{按旅客订票要求找到Aj};

int X1=Aj;

if(X1>=1) {

X1--;

Aj=X1;

{输出一张票};

} else

{输出信息"票已售完"};

}

2.主存管理问题（永远等待）

//memory为初始主存容量

int X=memory；

void borrow(int B) {

while(B>X)

{进程进入等待主存资源队列};

X=X-B ;

{修改主存分配表，进程获得主存资源};

}

void return(int B) {

X=X+B;

{修改主存分配表};

{释放等主存资源进程};

}

进程是运行着的程序：不仅包含代码，而且包含当前的活动状态：–程序计数器指明下一条要执行的指令

–处理器寄存器的内容

–进程栈：方法参数，返回地址，局部变量

–数据段：全局变量

进程是可并发执行的程序在某个数据集合上的一次计算活动，也是操作系统进行资源分配和保护的基本单位。

进程三态转换

?运行态?就绪态：时间片到货出现更高优先级的进程时，当前进程被迫让出处理器?就绪态?运行态：CPU空闲时，调度程序选中一个就绪进程执行

?运行态?等待态：运行进程等待使用某种资源或某事件发生

?等待态?就绪态：进程所需资源满足或某事件已经完成

进程生命周期

创建

?步1：在进程列表中增加一项，从PCB池中申请一个空闲PCB，为新进程分配惟一的进程标识符；

?步2：为新进程的进程映像分配地址空间，以便容纳进程实体。进程管理程序确定加载到进程地址空间中的程序；

?步3：为新进程分配除主存空间外的其他各种所需资源；

?步4：初始化PCB，如进程标识符、处理器初始状态、进程优先级等；

?步5：把新进程状态置为就绪态，并移入就绪进程队列；

?步6：通知操作系统的某些模块，如记账程序、性能监控程序。

撤销

?步1根据撤销进程标识号，从相应队列中找到并移除；

?步2将该进程拥有的资源归还给父进程或操作系统；

?步3若该进程拥有子进程，先撤销它的所有子进程，以防它们脱离控制；

?步4回收PCB，并归还到PCB池。

进程阻塞和唤醒（自学了解）

?进程阻塞步骤：

–步1停止进程执行，保存现场信息到PCB；

–步2修改进程PCB有关内容，如进程状态由运行态改为等待态等，并把修改状态后的进程移入相应事件的等待队列中；

–步3转入进程调度程序去调度其他进程运行。

?进程唤醒步骤：

–步1从相应的等待队列中移出进程；

–步2修改进程PCB的有关信息，如进程状态改为就绪态，并移入就绪队列；

–步3若被唤醒进程比当前运行进程优先级高，重新设置调度标志

线程是操作系统进程中能够独立执行的实体（控制流），是处理器调度和分派的基本单位。作业周转与平均周转时间

?如果作业i提交给系统的时刻是ts，完成时刻是tf，该作业的周转时间ti为：ti = tf – ts（作业在系统里的等待时间与运行时间之和）

平均作业周转时间 T = (Σti) / n

作业带权周转时间和平均作业带权周转时间

?如果作业i的周转时间为ti，所需运行时间为tk，则称wi=ti /tk为该作业的带权周转时间。

?ti是等待时间与运行时间之和，故带权周转时间总大于1。

?平均作业带权周转时间W = (Σwi) / n

响应比

响应比＝1+已等待时间/估计运行时间

作业调度算法

（1）先来先服务算法（不可剥夺）

FCFS调度算法的平均作业周转时间与作业提交的顺序有关。具有相同优先级的进程使用FCFS，FCFS只考虑进程等候时间而忽视了作业的运行时间

缺点：重要进程无法得到及时响应，若大进程先到，容易导致平均等待时间过大，增加了进程的平均周转时间。

（2）短作业优先算法（不可剥夺）--作业运行时间事先估计

总选取估计计算时间最短的作业投入运行。只考虑用户估计的作业运行时间而忽视了作业等待时间

优点：作业同时到达的情况下，降低作业平均等待时间，提高系统吞吐量。

缺点：大进程饿死

（3）最短剩余时间优先（可剥夺式的短进程优先算法）

优点：保证及时响应，降低进程平均等待时间

缺点：系统开销增大，保存进程的运行情况以比较时间，剥夺本身消耗处理机时间（4）响应比最高者优先（不可剥夺）

优先数＝（要求服务时间+已等待时间）/（要求服务时间）

响应比=响应时间/服务时间

–短作业容易得到较高响应比，

–长作业等待时间足够长后，也将获得足够高的响应比，

–饥饿现象不会发生。

?优点：既考虑作业等待时间，又考虑作业的运行时间，既照顾短作业又不使长作业的等待时间过长，改进了调度性能。消除饥饿现象

（5）优先级调度算法（静态+动态）

1.根据进程占有CPU时间多少来决定,当进程占有CPU时间愈长,那么，在它被阻塞

之后再次获得调度的优先级就越低，反之,进程获得调度的可能性越大;

2.根据进程等待CPU时间多少来决定,当进程在就绪队列中等待时间愈长,那么，在

它被阻塞之后再次获得调度的优先级就越高，反之,进程获得调度的可能性越小。（6）多级反馈队列调度（了解）

多个进程就绪队列，每个序列有调度级别，优先级逐层降低。优先级最高的的序列时间片最小

缺页中断率

?假定作业p共计n页，系统分配给它的主存块只有m块（１≤m≤n）。如果作业p 在运行中成功的访问次数为s，不成功的访问次数为F，则总的访问次数Ａ为：

A = S + F

又定义：

f = F / A

称f为缺页中断率。影响缺页中断率f的因素有：

(1)主存页框数。

(2)页面大小。

(3)页面替换算法。

(4)程序特性。

I/O控制方式

(1)轮询方式

(2)中断方式

（3)DMA方式

静态地址重定位

?装载器将代码模块装入内存后，将所有逻辑地址修改成物理地址

–特点：

?无需硬件支持，易于实现

?无法实现代码模块的移动

动态地址重定位

?装载器不修改逻辑地址，而是通过将代码起始地址置入重定位寄存器（段寄存器）来实现寻址

?特点：

?需要硬件（重定位寄存器）支持

?可以实现代码的动态移动

进程互斥

进程互斥是指若干个进程因相互争夺独占型资源时所产生的竞争制约关系。

进程同步

进程同步指为完成共同任务的并发进程基于某个条件来协调它们的活动，因为需要在某些位置上排定执行的先后次序而等待、传递信号或消息所产生的协作制约关系。

临界区：并发进程中与共享变量有关的程序段

临界资源：共享变量代表的资源

原语：内核中执行时不可被中断的过程

信号量：

一个进程在某一特殊点上被迫停止执行直到接收到一个对应的特殊变量值，这种特殊变量就是信号量（一种软件资源）

死锁定义

?如果在一个进程集合中的每个进程都在等待只能由该集合中的其他一个进程才能引发的事件，则称一组进程或系统此时发生死锁。

死锁的四个必要条件

–互斥条件：进程互斥使用资源

–部分分配条件：申请新资源时不释放已占有资源

–不剥夺条件：一个进程不能抢夺其他进程占有的资源

–环路条件：存在一组进程循环等待资源的

死锁定理

?如果能在进程-资源分配图中消去此进程的所有请求边和分配边，成为孤立结点。经一系列简化，使所有进程成为孤立结点，则该图是可完全简化的；否则则称该图是不可完全简化的。

?系统为死锁状态的充分条件是：当且仅当该状态的进程-资源分配图是不可完全简化的。该充分条件称为死锁定理。

生产者-消费者

?item B[k];

?semaphore empty; empty=k; //可以使用的空缓冲区数

?semaphore full; full=0; //缓冲区内可以使用的产品数

?semaphore mutex; mutex=1; //互斥信号量

?int in=0; //放入缓冲区指针

?int out=0; //取出缓冲区指针

?cobegin

?process producer_i ( ){ process consumer_j ( ){

? while(true) { while(true) {

? produce( ); P(full);

? P(empty); P(mutex);

? P(mutex); take( ) from B[out];

? append to B[in]; out=(out+1)%k;

? in=(in+1)%k; V(mutex);

? V(mutex); V(empty);

? V(full); consume( );

? } }

} }

?coend

读者-写者

?int readcount=0;//读进程计数

?semaphore writeblock,mutex;

?writeblock=1;mutex=1;

?cobegin

?process reader_i( ){ process writer_j( ){

? P(mutex); P(writeblock);

? readcount++; {写文件};

? if(readcount==1) V(writeblock);

? P(writeblock); } ?V(mutex);

? {读文件};

? P(mutex);

? readcount--;

? if(readcount==0)

? V(writeblock);

? V(mutex);

?}

?coend

理发师

?int waiting=0;//等候理发顾客坐的椅子数

?int CHAIRS=N; //为顾客准备的椅子数

?semaphore customers,barbers,mutex;

?customers=0;barbers=0;mutex=1;

?cobegin

?process barber( ) {

? while(true) {

?P(customers); //有顾客吗？若无顾客，理发师睡眠?P(mutex); //若有顾客时，进入临界区

?waiting--; //等候顾客数少一个

? V(barbers); //理发师准备为顾客理发

?V(mutex); //退出临界区

?cut_hair(); //理发师正在理发(非临界区)

? }

?}

?process customer_i( ) {

? P(mutex); //进入临界区

? if(waiting

?waiting++; //等候顾客数加1

?V(customers); //唤醒理发师

?V(mutex); //退出临界区

?P(barbers); //理发师忙，顾客坐下等待

?get_haircut(); //否则顾客坐下理发

? } else

? V(mutex); //人满了，走吧！

?}

?Coend

哲学家吃面

semaphore fork[5];

for (int i=0;i<5;i++)

fork[i]= 1;

cobegin

process philosopher_i( ){/*i=0,1,2,3 */

while(true) {

think( )；

P(fork[i])； /*i=4,P(fork[0])*/

P(fork[(i+1)%5] )；/*i=4,P(fork[4])*/

eat( )；

V(fork[i])；

V(fork([i+ 1] % 5)；

}

}

coend

和尚吃水