北京理工大学操作系统复习——习题+知识点

传送门

由于操作系统知识太多，再加上我总结的比较细，所以一篇放不下，拆分成了多篇文章。

操作系统笔记——概述、进程、并发控制
操作系统笔记——储存器管理、文件系统、设备管理
操作系统笔记——Linux系统实例分析、Windows系统实例分析
北理工操作系统实验合集 | API解读与例子
北京理工大学操作系统复习——习题+知识点
资料包百度云下载，含2022年真题一套，提取码cyyy

前言

考完了，感觉难度一般，上课讲的很细节，我那三大篇笔记记得也很详细，结果考试难度很一般。

如果你去看我们这次的考试，你就会发现几乎所有知识点都被我这篇文章命中了，简单来说，如果把我这篇文章看完，知识点背了，100分的水平是有的，考出来是多少就看诸位运气了。

ppt习题+课后习题汇总

第1章 操作系统概论

操作系统性能指标计算

这里将CPU调度的时间忽略，三个任务的资源互不重叠，所以并行处理。

首先计算出总时间。分别是30min和15min。总时间是一切计算的基础。

然后看吞吐量。吞吐任务是3个job，除以时间得出吞吐量。所谓的吞吐量，实际上是单位时间完成任务数。

周转时间。因为任务是批量放入的，计算如下：

$$\begin{gathered} 多通道=\frac{5+15+10}{3}=10 \\ 单通道=\frac{(5)+(5+15)+(5+15+10)}{3}=\frac{55}{3}\approx 18 \end{gathered}$$

至于利用率，就是某一资源占用时间/总时间就可以，很明显，在利用不同资源的情况下，多通道系统的资源利用率是很高的。

第2章 进程管理

进程调度算法

基本的算法：

1. FCFS
2. 最短作业优先。可以将平均周转时间降到最低。
3. 响应比高优先，RP=1+$\frac{作业等待时间}{作业估计运行时间}$
4. 静态优先级/动态优先级
5. 时间片轮转
6. 多级反馈队列轮转

调度题一般分两部分：

1. 调度次序的计算。这种最好是通过画图来计算，上面画一个时间轴，画出任务执行的区间，下面画一个就绪队列，就绪队列的排序通过调度算法计算。注意，每次有新任务提交，就要在这个时间节点更新就绪队列，而这个时间节点并不一定是调度的时间节点。
2. 性能指标的计算。如第1章。

课后2-9：最短作业优先

这道题要明白，最小平均周转对应最短作业有限。确定了算法以后，假设X处在不同的区间，就可以给出不同的计算结果：

课后2-12：四种算法比较

这道题是经典的调度算法题。

1. 计算调度顺序的时候最好画图做。上面画一个时间轴，画出任务执行的区间，下面画一个就绪队列，就绪队列的排序通过调度算法计算。注意，每次有新任务提交，就要在这个时间节点更新就绪队列，而这个时间节点并不一定是调度的时间节点。
2. 性能指标一般算平均周转。可以看到，最短作业的平均周转是最小的。
   • 平均周转时间=周转总时间/作业总个数
   • 带权周转时间=周转时间/运行时间
   • 平均带权周转时间=带权周转总时间/作业总个数

各个作业的平均带权周转时间W计算如下：
W=(2/2+2.2/1.2+2.2/0.5+1.8/0.3)=(1+1.83+4.4+6)/4=3.307

各个作业的平均带权周转时间W计算如下：
W=(2/2+3/1.2+1/0.5+0.6/0.3)/4=1.875

各个作业的平均带权周转时间计算如下：
W=(2/2+2.7/1.2+1/0.5+1.8/0.3)/4=2.8125

课后2-13：轮转与优先级调度

（1）轮转法（假定时间片=2分钟）
作业完成的顺序为C,D,B,E,A
开始作业轮转一周需10分钟，
作业C的周转时间：Tc=10分钟 （6分）
C完成后，剩下四个作业，轮转一周需8分钟,
作业D的周转时间：Td=10+8×(4-2)/2=18分钟（16分）
D完成后，剩下三个作业，轮转一周需6分钟,
作业B的周转时间：Tb=18+6×(6-2-2)/2=24分钟（22分）
B完成后，剩下两个作业，轮转一周需4分钟,
作业E的周转时间：Te=24+4=28分钟（28分）
E完成后，只剩下作业A,
作业A的周转时间：Ta=28+2=30分钟（30分）
平均周转时间： T=(10+18+24+28+30)/5=22分（20.4分）

第3章 并发控制

进程同步

生产者消费者问题

经典的k缓冲区模型。

1. empty：表示空缓冲区的个数，初值为k
2. full：有数据的缓冲区个数，初值为0
3. mutex：互斥访问临界区的信号量，初值为1

注意，要先确认是否可用，再P（mutex），否则会造成死锁。

理发师问题——阻塞进程有上限

一个理发师，一把理发椅，n把等候理发的顾客椅子，如果没有顾客则理发师便在理发椅上睡觉 ，当有一个顾客到达时，首先看理发师在干什么，如果理发师在睡觉，则唤醒理发师理发，如果理发师正在理发，则查看是否有空的顾客椅子可坐， 如果有，坐下等待，如果没有，则离开。

理发师问题在生产着消费者问题上，增加了满座则走的判断。下面我写的代码版本是直接从生产者消费者改过来的，实际上，还有另一种写法更加常用，后面给出。

int customer=0,cheer=n
int mutex=1

Barber:
while(1)
{
	P(customer)
	P(mutex)
	理发
	V(cheer)
	V(mutex)
}

Customer:
while(1)
{
	P(mutex)
	if(cheer==0)//没有空椅子，离开
	{
		离开
		V(mutex)
	}
	else
	{
		P(cheer)
		V(customer)
		V(mutex)
		等待理发
	}
}

下面是另一种写法：在这个写法里，顾客来了要先V再P，因为customer代表顾客数量。
之后就是新增了一个waiting变量，其实这个变量和customer值相同，所以其实和我的思路也没太大区别，只是更贴近实际编程罢了。

信号量 customer = 0; // 顾客资源数
信号量 server = 0; // 服务人员资源数
信号量 mutex = 1;
int waiting = 0; // 正在等待的顾客数量

Server(){
    while(1){
        P(customer); 
        P(mutex); //
        叫号;
        waiting--;
        V(mutex); //
        V(server);
        提供服务;
    }
}

Customer(){
    P(mutex); //
    if (waiting < M){
        取号;
        waiting++;
        V(mutex); //
        V(customer);
        P(server);
        被服务;
    }
    else{
        V(mutex);
        离店;
    }
}

果盘问题——一个缓冲区两种资源

这个例子没有加互斥PV信号量，可以选择加一个。

哲学家进餐问题——一次申请多种资源

这题比较简单，就是设置5种资源，每种都是1。之后每个进程（哲学家）要P两次，对应两种不同资源。

这两个同步P，可以推广到多种，而且位置关系也不一定是相邻。总之是一次申请多种/多个资源。

读写问题——通过带条件的PV确立优先级

读者优先

读写策略是很多的，前面只是给出一种读者优先策略，这种策略比较粗糙，和我们实际中的不一样。比如你正在用notepad++读取一个文本，但是用windows txt修改文本（写）仍然是可以的，并且之后npp会重新加载文本。

读者优先策略描述如下：

1. 多进程可以同时读
2. 只允许一个进程写
3. 读者会阻止写者进入

分析：

1. 写写互斥，读写互斥。所以有rmutex和wmutex。
2. 读读不互斥，但是可以设置读取上限

代码分析：

1. 首先实现读写互斥，和写写互斥。最简单的思路就是用一个wmutex，给读写都加上锁。但是这样会带来一个问题，就是读读也会互斥
2. 为了解决读读互斥，需要加入if条件与一个int值——readcount判断是否有进程在读。如果已经获取了wmutex（有进程在读，readcount＞0），那就不需要再申请wmutex了。如果没有进程获取wmutex（readcount==0），就申请一个wmutex，把写操作排斥。在读操作完毕后，readcount–，表示减少一个读取进程，当减到0以后，就要释放wmutex。
3. 问题来了，rmutex又有什么用？rmutex其实就和我们前面生产者消费者里的mutex用法一样，是防止多进程访问共享变量的时候，readcount自增自减被打断，出现幽灵数据的问题。但是注意粒度要细，不要把中间的读取区域覆盖了。

最后讨论一下附加问题，能否限制读取进程上限？加一个readmax信号量就好，设为5。下面代码的P（readmax）放在了读取操作的前面。

	  int readmax=5;
Reader：
begin
		P(rmutex);
		if(readcount==0)then P(wmutex);
		readcount++;
		V(rmutex);
		P(readmax);
		read_file();
		V(readmax);
		P(rmutex);
		readcount=readcount-1;
		if(readcount==0)then V(wmutex);
		V(rmutex);
	end

writer:
begin
   p(wmutex);
   write data;
   v(wmutex);
   …
end

写者优先

1. 可以多个读者
2. 写者会阻止读者进入
3. 写者可以插队

从本质上来说，优先级就是通过if判断的。如果一个进程可以通过if跳过P操作，那是不是就意味着优先级更高？所以，读者写者问题的核心就在于如何通过if构造优先级。如果读写进程都用一个互斥量，不加if，那就是公平，如果想给谁提升优先级，就给谁加if。

写者优先基于读者优先改进，在最外面加了一个互斥量，这个互斥量x可以理解为有写进程的标志，如果一直有写进程进入，这个标志就一直是0，就会屏蔽读者的进入。

int readcount,writecount;
semaphore rmutex=1,wmutex=1,rwmutex=1,x=1;
reader：
		p(x);   //一个读进程与一个写进程在x上竞争
		p(rmutex);  //读进程互斥访问readcount
		++readcount;
		if(readcount==1) p(rwmutex); 
		v(rmutex);
		v(x);
		read data;  //临界区
		p(rmutex);
		--readcount;
		if(readcount==0) v(rwmutex);
		v(rmutex);

Writer：
		p(wmutex);      //写进程互斥访问writecount
		++writecount;
		if(writecount==1) p(x);  //一个写进程与一个读进程在x上竞争
		v(wmutex);
		p(rwmutex);     //其他写进程在rwmutex上排队
		write data;  //临界区
		v(rwmutex);
		p(wmutex);
		--writecount;
		if(writecount==0) v(x); //写进程都写完时，通过v(x)允许读进程读
		v(wmutex);

读写公平

1. 允许多个读者
2. 读者存在会阻止写者进入，写者存在会阻止读者进入。

因为没有优先级，所以就撤掉写者对z变量的优先级（if），两个进程对z都没有if，就不存在插队问题：

int rmutex=1,rwmutex=1,readcount=0;
reader:
begin
   p(z);   //读写进程在z上排队。
   p(rmutex);
   if(readcount=0) then p(rwmutex);
   end if
   ++readcount;
   v(rmutex);
   v(z);   //无写者时，多个读者可以同时读.
   read data;
   p(rmutex);
   --readcount;
   if(readcount=0 then v(rwmutex);
   end if;
   v(rmutex);
   …
end
writer:
begin
   p(z);   //读写进程在z上排队。
   p(rwmutex);
   write data;
   v(rwmutex);
   v(z);
   …
end

死锁问题——银行家算法

一类资源

先看一个简单的例子，理解思想。

从a到b是一个正常的分配过程，但是b到c就会陷入危险状态。
如何预测？就看我把资源全部交给某一个任务后，他能不能完成任务。如果不能完成任务，系统的资源没了，进程也还在等资源。

用b举例，A需要5，B需要4，C需要2，D需要4，系统有2，如果给C，就可以，但是给其他顾客，系统就会陷入危险。比如给了c，资源就不够了，直接卡死。

多种资源

以上只是一类资源，实际中有多类资源，会构成一个矩阵。一般是横轴为进程，纵轴为资源类型。相对应的，系统资源也变成了一个横向量。具体做的只是把前面的过程按资源遍历一次就行。

有如下矩阵：

1. 最大需求矩阵。固定
2. 已分配矩阵。
3. 剩余需求矩阵。最大需求矩阵-已分配矩阵
4. 总资源向量。固定
5. 剩余资源向量。总资源向量-已分配矩阵按第二维求和

两步走：

1. 判断安全性。计算系统是否安全，就用剩余资源向量和剩余需求矩阵比，只要有一行（对应一个进程）的资源可以被剩余资源向量完全满足，那就是安全的。
2. 资源分配与回收。把分配给一行以后，资源释放，将已分配矩阵和剩余需求矩阵中的对应行划掉，把对应行之前占用的资源加到剩余资源向量中，资源回收。

由此就完成一个分配，之后不断执行，直到全部完成或者死锁。

上面的例题中，系统是安全的。因为根据剩余请求矩阵R，可以找到一个进程完成序列 P4, P1, P2, P3, P5。

课后3-7：简化版生产着消费者

这是生产者消费者的简化版，缓冲区=1的情况。注意的是，发送与接受同步，对缓冲区的操作要用mutex互斥。

课后3-8：缓冲区数据结构——循环队列

从数据结构来说，缓冲区是一个循环队列。循环队列中，in代表要放置的位置（放置前为空）。当IN = OUT时，说明缓冲区已空。已知循环缓冲区的容量为100，则当（IN+1）%100 = OUT时，说明缓冲区已满。

总的来说，循环队列牺牲了一个空间，换取了满的判断。

课后3-9：自产自销分阶段生产者消费者

纯纯生产者消费者，只不过是自产自销，且将产销分成了两阶段。

登记过程：               擦除过程：
     begin                     begin
 p(empty)                  p(mutex)
 p(mutex)                  找到自己的登记项擦除
 找到一个登记项登记       	   v(mutex)
 v(mutex)                  v(empty)
     end                      end

读书：
begin
  调用登记过程
  进入阅览室阅读
  准备退出
  调用擦除过程
end

课后3-14：死锁的理论证明

这就是个理论证明。有的题，比如课后3-19，会让你去判断某种情况会不会发生死锁，这个定 理是极限情况，只要满足这个定理，就不会死锁。

课后3-15：进程优先关系图的实现

简单说，就是让不优先的进行P操作，等优先的对象都执行完，使用V操作释放信号量后，才能执行。

可以看到，M1比M234优先，所以M1要给M234三个进程释放信号量，那三个进程刚开始都会用P操作阻塞，等M1释放信号量。其他的进程也是以此类推，被制约就是P操作，制约其他进程就是V操作，有几个关系就有几个P/V

课后3-16：哲学家进餐问题的死锁情况

（1）每人各拿一个叉子。

（2）银行家算法，在哲学家进行第一个P操作之前，检测状态是否安全。如果其余4个进程各自占有一个资源，当前进程就要休眠。

课后3-17：读写问题的三种优先策略

详见前面的PV例子。总的来说，就是在外面再加一个互斥信号量用于排队，优先的进程可以通过if跳过信号量排队。

课后3-18：有上限的理发师问题

n把椅子，椅子不够就离开。详见前面PV例子。

课后3-19：通过死锁定理判断死锁可能性

前面3-14推出一个定理。只要当前情况比定理更加宽松或者符合定理，都不会发生死锁。

（2）和（4）会发生死锁。

课后3-20：银行家算法

（1）

P1占有5个资源，剩余3个资源请求。运行态。
P2占有2个资源，剩余4个资源请求。阻塞态。
P3占有0个资源，剩余7个资源请求。阻塞态。
系统剩余3个资源。

（2）P1的请求最先满足。进程完成序列：P1，P2，P3。

课后3-21：银行家算法

剩余资源向量：Available=(1 5 0 2)

（2）当前系统是安全的。
判断系统是否安全，只要检查系统剩余资源向量能否对各进程的剩余请求向量找到一个进程完成序列，当按照这个序列为各进程分配资源时，各进程都能成功完成。若能找到，则系统是安全的，否则，为不安全。
先找到p0, 因为p0已满足最大资源请求，它可以完成，释放其占有的资源，使系统剩余资源向量为（1 5 1 4）
之后，系统剩余资源向量（1 5 1 4），可满足进程p2, 使p2 可以完成，释放其占有的资源，使系统剩余资源向量为（2 8 6 8）。
之后无论选哪一个进程都可成功完成。
故找到的进程完成序列可为：p0,p2,p4,p3,p1; 或 p0,p2,p3,p1,p4 等，故系统是安全的。

（3）因系统剩余可用向量为（1502），p2的剩余请求向量为（1002），即（1502）>（1002）。故，当p2提出（1001）请求时，能满足。进程完成序列：p0,p2,p4,p3,p1

第4章 储存器管理

逻辑地址转换，多级页表计算

一级页表转换

二级页表转换

二级页表总空间计算

（假设页框为4K大）

当有1K个页的时候，就需要1K个页描述符，一个页描述符有32位4B的大小，所以这些页描述符构成一个4K的页表，正好塞满一个页框。也就是说，超过1K页的时候就要用二级索引了。

同理，一个页目录表最多放1K个页表描述符，所以一个页目录表最多对应1K×1K=1M个页，即1M×4K=4G的空间。

现在电脑不止4G了，但是对应的，地址总线也变成了64位，寄存器也会变，包括页大小之类的，但是总之，计算的思路就这么简单。

页面置换算法

经典4种

1. OPT算法是直接找到对应页位置进行替换。
   
2. FIFO算法会对页面对列进行整体下移。
   
3. LRU在FIFO的基础上，会将最近使用的页提升到最上面
   
4. clock算法和OPT一样，都是直接原位替换。但是clock算法新增引用位，发生S后，会重置引用位，相当于一次免死金牌。注意，发生F且置换后，指针停留在新页面的下一位。
   

例题：逻辑地址转换+clock算法

13DEH，0001 0011 1101 1110，去掉后10位得到前面的数为00 0100 即4，发生缺页中断。
按照题意，最早指针指向2，所以经过缺页中断后，2号页变成了4号页，页框不变。

现在进行地址映射。将13页框，1101，前面补2个0得到001101，最后补上逻辑地址后半截1111011110，变成物理地址（其实这一步提前做也可以，反正缺页中断前后目标物理页框号是不变的）

课后4-14：可变分区分配算法

（1）若采用首次适应法：
12K的请求：将分配40K的空闲块， 40K变为剩余的（40-12）K=28K，空闲队列变为：10K，28K，20K，18K，7K，9K，12K和15K；
10K的请求：将分配10K的空闲块，空闲队列变为：28K，20K，18K，7K，9K，12K和15K；
9K的请求：将分配28K的空闲块，空闲队列变为：（28-9）=18K，20K，18K，7K，9K，12K和15K；

（2）若采用最佳适应法：
12K的请求：将分配12K的空闲块，空闲队列变为：10K，40K，20K，18K，7K，9K和15K；
10K的请求：将分配10K的空闲块，空闲队列变为：40K，20K，18K，7K，9K，12K和15K；
9K的请求：将分配9K的空闲块，空闲队列变为： 40K，20K，18K，7K， 12K和15K；

（3）若采用最坏适应法：
12K的请求，将分配40K的空闲块，空闲队列变为：10K，28K，20K，18K，7K，9K和15K；
10K的请求：将分配28K的空闲块，空闲队列变为： 20K，18K，7K，9K，12K和15K；
9K的请求：将分配20K的空闲块，空闲队列变为：10K，18K，11K， 18K，7K， 12K和15K。

课后4-15：页式管理逻辑地址转物理地址

有些题（比如这次考试）给的是16进制的逻辑地址，这种题应该进行地址分段，后半段12位是页内偏移（4KB页大小），前面半段是逻辑页号，转成物理页号后再拼接成真正的物理地址。

但是注意，这道题给出的是10进制的地址，因此有两种处理方法：

1. 转16进制后套用前面的思路，这样比较麻烦
2. 从本质上来说，直接用十进制地址除以页大小也可以获得逻辑页号，算起来比较简单。

课后4-16：页面调度算法

FIFO和LRU都会使得页面的列向下移动。

OPT会直接到淘汰位置进行替换，不需要整体推动页号列。需要注意的是，序列末端相对宽松一些，可以替换的位置比较多。

课后4-17：段式管理逻辑地址转物理地址

不同于页式管理，段式管理必须给出逻辑段号，因为段长不确定，不能进行整除计算。

注意一下段表越界和段内越界。

（1）0，430 219+430=649
（2）1，10 2300+10=2310
（3）2，500 500＞100段内地址越界
（4）3，400 1326+400=1726
（5）4，112 112＞96 段内地址越界

课后4-18：页式管理之页大小的影响

这道题的核心是，储存的最小单位是页，计算的时候要向上取整。因此，页大小越小，更能储存一些特殊大小的信息，但是也会带来不易管理的问题。

（1）

存储空间每块为4096个字节，共可分成16块。
程序代码段占32768/4096=8块，数据段占16386/4096=5块，栈段占15870/4096=4块，合计为8+5+4=17块，故该机器的主存空间不适合这个作业。

（2）

当存储空间每块为512个字节，共可分成128块。
程序代码段占32768/512=64块，数据段占16386/512=33块，栈段占15870/512=31块，合计为64+33+31=128块，故该机器的主存空间是适合这个作业的。

课后4-19：逻辑地址分段理解

这道题考察对逻辑地址分段的理解。在页式管理中：

1. 页内偏移的位数与也大小要匹配，比如4KB要用12位偏移描述，1KB用10位偏移，以此类推。
2. 页面基址=页号×页面大小，那么一个页表里的页描述符数量就决定了编码逻辑页号的位数。如果是512项，就用9位，1024项，就用10位。

在这道题中：

1. 1KB页大小对应10位页内偏移。
2. 512个页描述符对应9位编码。其实512这个条件完全不需要给。每个页描述符占16位，即2B，一页1024KB，则很容易就可以算出一个页表可以容纳的页目录数量=512个，对应9位编码。

课后4-20：缺页中断的理解

（1）

每页存放200个整数，也就是可以放2行矩阵数据。

程序A顺次访问100行，每处理2行，上次调入的页就会失效，就会进行一次缺页中断。所以是50次中断。

程序B顺次访问100列，每一列中顺次访问100行。也就是说，每一列都会发生50次缺页中断，所以100列就是5000次缺页中断。

（2）

每页存放100个整数，则对应1行矩阵数据，缺页中断次数全部翻倍。

A100次，B10000次

课后4-21：内存读写时间计算

答案=0.9×(0.75×1+0.25×8)+0.10×(8+5000+8)+8

懵逼了？来看一下解析：

读取流程，假设内存逐级寻址和读取的平均时间都是8ns：

1. 寻址时间为0.9×(0.75×1+0.25×8)+0.10×(8+5000+8)。有0.9的概率在内存中能找到，有0.1几率在内存中找不到。
   • 内存中找到：快表和直接寻址是并行的，所以即使快表没有命中，也不会额外消耗时间。（假如是串行的，这个时间就是0.75×1+0.25×(1+8)）
   • 内外存交换：先花8ns在内存寻址，没找到，花5000ns交换，之后再花8ns寻址
2. 读取时间为8。读取假设花费8ns时长

课后4-23：页表级数计算

总内存=$2^{64}B$

内存中页框数=$\frac{2^{64}}{2^{13}}=2^{51}$

一个页框可以放下的描述符数量=$\frac{2^{13}}{2^2}=2^{11}$

所以需要的页表级数为$\frac{51}{11}$，向上取整，即5级。

第5章 文件系统

课后5-9：位示图/自由块链表空间计算

盘空间用D位表示，即用D位去描述盘块编号，也就是说储存一个盘块的位置要用D位。

一磁盘有B个盘块，用位图表示要使用B位。现有F个自由块，若表示一个盘块需用D位。则采用链表接连F个盘块，需要F个链指针，共占FD位。使用自由块链表比使用位示图占用更少的空间的条件是FD<B。

当D=16时，满足条件的自由空间占整个空间的百分比为：F/B<1/16=6.25%。

课后5-10：读盘块速度计算

这里注意，类似于快表，这里的缓冲机制和直接寻找也是并行的。

n×1+（1-n）×40=40-39n

课后5-13：链接方式的逻辑地址转物理地址

10个记录，放5个块，即一个块放两个记录。

访问1574字节数据，对应第7个记录，对应第4个块，从链接文件里看，对应物理块号4。应访问4号块内的第38个字节。

链接文件的指针在物理块内，所以是顺序读取，n个逻辑块要读取n次，所以要访问4次磁盘才能将该字节的内容读出。

课后5-14：多级目录读取与文件打开（坑）

共需要4次磁盘操作。

1. 首先要用4次读取获取os的目录。根目录已经有缓冲，读取user的目录，读取lim的目录，读取course的目录，读取os的目录，这四次读取就可以确定result.txt文件的磁盘块位置。
2. 进一步不需要读取了。这里有个坑，打开和读取是不一样的，打开仅仅是在进程中创建一个file对象，指定一个dentry对象，并不需要读取物理块。读取文件才需要进行磁盘读取。

课后5-15：多级索引占用空间计算

其实假定一个索引项占2B是可有可无的。因为空间是1G，所以可以分成$\frac{2^{30}}{16KB}=2^{16}$块，也就是说，物理块空间可以用16位（2B）的长度的索引去编码。

1. 10KB<16KB, 所以，只占用1个磁盘块。
2. 1089KB/16KB=69 需一个索引块和69个数据块，共70个盘块。
3. 129MB/16KB=8256 ， 16KB/2B=8K（个索引项）<8256。一级索引装不下。
   • 所以首先需要一个二级索引表，占用1块。
   • 然后需要两个一级索引表，占用2块。
   • 最后需要8256个块储存数据。

总计：（1）+（1+69）+（1+2+8256）块。

Linux文件系统中inode索引物理块计算

15个元素的数组，其实就是索引表。我们捋一下多级索引，假设一个盘块的大小为b，则满打满算，只储存块索引，可以存$\frac{b}{4}$个索引。

1. 0-11索引号是直接索引。数值本身就是物理块号，对应逻辑上0-11的块
2. 12号是一次索引。经过一次索引，一个索引块可以储存$\frac{b}{4}$个索引，所以一次索引的区间长度就是$\frac{b}{4}$，所以其对应逻辑块区间为：12到$\frac{b}{4}$+11
3. 13号是二次索引。二次索引，可以储存的区间长度为$(\frac{b}{4}{)}^2$，所以其对应逻辑块区间为：$\frac{b}{4}$+12到$\frac{b}{4}$+$(\frac{b}{4}{)}^2$+11
4. 14号是三次索引。以此类推，区间长度为$(\frac{b}{4}{)}^3$，所以逻辑块号区间为$\frac{b}{4}$+$(\frac{b}{4}{)}^2$+12到$\frac{b}{4}$+$(\frac{b}{4}{)}^2$+$(\frac{b}{4}{)}^3$+11

第6章 设备管理

磁盘寻道时间计算

寻道时间、旋转延迟时间、读/写传输时间。

1. 寻道时间。最费时间的操作。
2. 旋转延迟。从零扇区开始处到达目的地花费的时间，这里是平均值，为旋转一周的时间的一半。
3. 数据传送。读取b个扇区，一个扇区要花费$\frac{1}{N}$份旋转时间

磁盘寻道算法

经典算法

1. FIFO
   
2. 最近距离优先
   
3. SCAN算法，走到头就返回
   
4. C-SCAN。走到头，先折返（折返过程中不处理），再重头开始。一般说C-SCAN都是指C-look
   
5. C-LOOK。起始和折返位置由任务序列决定
   

例题：磁盘调度

从这道题可以看出，说C-SCAN，起始都默认你用C-LOOK

（1）

2048（2K）×8=16384，刚好够位示图。

（2）

假定120为磁道上限

如果用纯C-SCAN，则需要（120-100）+（120-0）+（90-0）=230个单位
如果是C-LOOK，则需要（120-100）+（120-30）+（90-30）=170个单位（由此可见，没有明确说，默认都用C-LOOK）

0.01×0.5×4是4次读取的平均等待时间
0.0001×4是读取4个扇区的时间

2022年易考知识点总结

这里只是给出比较简洁，有针对性的总结，如果要系统一些，还是建议刷一遍文章。

第1章 操作系统概论

早期操作系统设计的主要目标是什么?

1. 向上易用性
2. 本身可维护
3. 向下高效率

操作系统是资源管理程序，它管理系统中的什么资源？

软硬件资源。

1. 硬件比如CPU，显示器，打印机
2. 软件比如各种进程（程序）。

为什么要引入多道（批处理）程序系统?它有什么特点？

提高CPU的利用效率，让CPU在一个任务IO的同时，在另一个任务上保持忙碌。

特点：

1. 宏观并行。多通道系统可以做到宏观上的并行
2. 微观串行。但是实际上，不同任务微观上在一个CPU上还是串行，一个CPU上不能同时有两个任务运行，仅仅是实现了CPU与IO的并行。

（实现这一系统需要很多硬件基础，比如中断技术（事件驱动），通道处理器（自动执行IO），主存技术（多程序同时运行）等等。）

叙述操作系统的基本功能。

总的来说

1. 向上，为用户提供简洁易用的系统接口，让用户更好地操作硬件。
2. 向下，管理计算机的软硬件资源，提高系统运行的效率。

具体有4个方面，这四个方面就是操作系统学习的几个章节目录：

1. 处理器管理。管理进程，如何调度处理器。
2. 储存器管理。分级管理各种储存器。寄存器，高速缓存，内存，外存。
3. 文件管理。对大容量外存进行更有序地组织。
4. 设备管理。如题。

其实向上和向下并不是完全分割的，比如文件管理，既可以提高效率，也给用户提供了简洁易用的接口。

批处理系统、分时系统和实时系统各有什么特点?各适合应用于哪些方面?

1. 批处理系统：多任务，宏观并行，微观串行
2. 分时系统：同时性（更强的并行性），独立性，交互性，及时性
3. 实时系统：实时性（优先级并行），确定性，可靠性

批处理系统广泛用于多任务，批量计算场景，分时系统用于多用户场景，实时系统用于要求快速响应，高可靠性的场景。

操作系统的特性?

1. 并发性。程序之间并发
2. 共享性。程序之间共享资源。并发性的基础是共享资源
3. 虚拟性。把一个实物资源变成若干个逻辑上虚拟资源，支撑了多用户的使用。比如虚拟机，虚拟打印机。
4. 异步性（随机性）。最后的异步性其实是一个缺点，并发与资源之间的制约导致进程之间的调度不完全由管理员和用户控制。

衡量OS的性能指标有哪些？什么是吞吐量、响应时间和周转时间？

资源利用率，吞吐量，（平均）周转时间，响应时间。

1. 资源利用率。这个指标是针对某个资源计算的，比如CPU，比如打印机，比如磁盘。资源利用率就是某个资源使用的时间比例。一直在运转就是100%利用 率
2. 吞吐量。完成任务的速度
3. 周转时间。一个任务在系统内的总时间。
4. 响应时间。计算机对用户的请求做出反应的时间，其中包含了计算机调度+周转的时间，响应时间总是比周转时间更长一些。

什么是嵌入式系统？

嵌入式系统是对基本操作系统进行选择性裁剪形成的简化版系统，安装在硬件较差的嵌入式设备里。

什么是对称多处理？它有什么好处？

在多处理器操作系统中，多个处理器是平等的。好处在于可以充分共享资源，提高效率。

为了实现系统保护，CPU通常有哪两种工作状态？各种状态下分别执行什么程序？什么时候发生状态转换？状态转换由谁实现的？

用户态，执行用户程序，核心态，执行操作系统内核程序。

当用户程序调用系统命令的时候，切换到核心态。核心态代码执行完毕后，切换回用户态。

这些切换涉及到安全问题，肯定不能由用户实现。用户到核心通过硬件中断实现，核心到用户通过内核程序实现。

中断可以理解为消息，用户态向内核发送一个中断，内核允许用户态执行系统调用后会切换为核心态。

什么是系统调用？什么是特权指令？特权指令执行时，CPU处于哪种工作状态？

用户调用操作系统内核API。
特权是指令集的一部分特殊指令，关系到系统全局，必须由核心态CPU执行。

操作系统通常向用户提供哪几种类型的接口?其主要作用是什么?

1. 操作接口，分为命令行接口与窗口界面。
2. 编程接口，通过系统调用实现。

第2章 进程管理

程序顺序执行的特点

1. 独占性。程序独占所有资源，直到执行完毕。
2. 封闭性。因为独占，所以不受干扰，体现出与外部干扰隔绝的封闭性
3. 可再现性。因为不受干扰，所以总是能按照既定计划完成，可复现。

何谓进程，进程由哪些部分组成？试述进程的四大特性（动态性、独立性、并发性、结构性）及进程和程序的区别。

进程没有特定的概念，大致上相当于一个任务，一个正在执行的程序。进程由程序，数据，PCB组成

1. 动态性。进程在程序执行之初创建，执行后释放。
2. 独立性。系统以进程为单位调度资源，每个进程是一个独立单位。
3. 并发性。多进程可以在一CPU上交叉运行
4. 结构型。进程由PCB块进行控制

进程是动态，临时的，程序是静态的，永久的。程序相当于任务的规划，进程相当于任务的具体执行。

进程控制块的作用是什么?它主要包括哪几部分内容?

记录进程的元数据，控制进程的调度。

1. 进程标识符。
2. 进程状态，调度，储存器管理的信息。比如进程状态，优先级，程序的地址。
3. 进程的资源信息。进程打开的设备，文件。
4. CPU现场保护区。比如寄存器信息。

进程的基本状态，试举出使进程状态发生变化的事件并描绘它的状态转换图。

三种基本状态：就绪态（有资源无CPU），运行态，阻塞态（有CPU但无资源）
两种额外状态：创建态（不会占用资源），终止态（结束但资源还没释放）

什么是原语?什么是进程控制？

操作系统对进程的控制操作，具有原子性，不可以被中断。
原语大致有这么几种：

1. 创建/撤销原语。对应进程的创建与销毁
2. 阻塞/唤醒原语。对应进程从运行态到阻塞态，以及从阻塞态到就绪态
3. 挂起/解挂原语。对应进程的主动暂停，继续。

进程控制包括进程的创建，销毁，状态转换。

进程调度的功能、方式、时机、算法。作业调度，交换调度。作业的周转时间和作业的带权周转时间?

功能：

1. 管理系统中各种进程的PCB块。
2. 选择进程进行CPU占领
3. 与CPU占领伴随的是上下文切换。

方式：

1. 非剥夺方式。比如批处理
2. 剥夺方式。有优先级，可以抢占。

时机：

1. 执行完了或者卡住了。进程完成，等待IO
2. 被调度了。比如分时系统中，时间用完了。又或者更高优先级的过来了，就会被切换到就绪态或者阻塞态。

算法：

1. 先来先服务（FCFS，First come First serve）。就是曾经的单通道批处理系统，缺点很明显，所有任务都是阻塞的，如果出现耗时操作，系统会卡很久。
2. 最短作业优先。就是对作业长短进行排序，对单通道批处理做出了一些优化。但是对长作业有点亏，本来就耗时，还要等，如果再有短作业不断插入进来，长作业就没法执行了，这种叫长作业饥饿状态。
3. 响应比高者优先。RP=1+$\frac{作业等待时间}{作业估计运行时间}$，RP大的先执行。直观看，等的越久，越应该放前面，耗时越短，越应该放前面。总的来说，是1，2算法的结合，缺点是计算量较大。
4. 优先级调度算法需要单独拿出来说。简单说就是将CPU分配给就绪队列中优先级最高的进程。
   • 静态优先级：在进程创建时确定的，运行时保持不变。通常赋予系统进程较高优先级（重要的）；赋予申请资源量少的进程较高优先级（不耗时的）。
   • 动态优先级：原优先级可随进程的推进而改变。根据进程占用CPU或等待CPU时间的长短动态调整。
5. 轮转法（RR，Round Robin）。进程地位是平等的，但是时间片长度需要考虑，太长了就失去了并行优势，太短了会增加调度开销。
6. 多级反馈队列轮转法。这是优先级+轮转法的结合。说白了就是，优先级算法中，一个优先级只对应一个进程，但是在这里，一个优先级对应一整个队列的进程。
   • 整体过程。多个队列，对应不同优先级。高优先级的队列先轮转，清空队列后再轮转低优先级。在每一个队列内部，进程地位平等，进行轮转。
   • 时间片长短问题。整体轮转过程中，为了防止低优先级进程饿死，分配给高优先级的时间片比较短（但是优先），低优先级的较长（虽然不容易轮到，但是一旦轮到就可以安稳执行完毕）。
   • 动态优先级。当然，优先级并不是一成不变的，具体的变化比较复杂。比如刚创建的默认放在高优先级，但是如果检测到占用时间过长或者卡IO了，就会降级。

线程的定义，线程与进程的比较。系统对线程的支持（用户级线程、核心级线程、两级组合）

一个进程对应若干线程，线程是进程中指令执行流的最小单元，CPU调度的基本单位。

1. 资源。一个进程的资源是独立的，而线程之间的资源大部分是共享的。
2. 调度。进程切换的上下文开销很大，线程切换只需要变动一点点信息，效率更高。
3. 并发性。线程的并发粒度更细
4. 安全性。进程之间资源隔离，互不影响。线程之间资源共享，一个线程的数据出问题会导致其他线程出错。

系统对线程的支持：

1. 用户级线程（多对一）。线程由用户控制，内核只知道进程的存在。由此，线程阻塞会导致内核判定进程阻塞，而且进程间线程切换无法实现。
2. 内核级线程（一对一）。线程由内核控制，专门建立一张线程表，用户通过系统调用实现多线程。可以解决用户级线程的阻塞以及切换问题，但是效率很低。
3. 混合模型（多对多）。进程内线程切换由用户级线程实现，进程间线程切换由内核实现，兼顾效率和并行性。

第3章 并发控制

并发执行的进程在系统中通常表现为几种关系?各是在什么情况下发生的?

1. 间接制约。进程之间因为使用临界资源而互斥。
2. 直接制约。进程之间因为协作而必须同步，比如一个进程要等上一个进程执行完才能执行。
3. 前序关系。由于进程的互斥同步关系，使得进程之间有了复杂的拓扑顺序

什么叫临界资源?什么叫临界区?对临界区的使用应符合的四个准则（互斥使用、让权等待、有空让进、有限等待）。

临界资源首先是共享资源。其次，临界资源同一时间只能由一个进程使用。

临界区就是访问临界资源的代码区域。

临界区使用准则：

1. 互斥使用。基本原则
2. 让权等待（没空就等）。等待的时候进入阻塞态
3. 有空让进（有空就可以进），进程之间地位平等，来了就都有机会进入临界区
4. 有限等待，不能让等待区中的进程饿死

解决进程之间互斥的办法： 开、关中断，加锁、开锁（又叫测试与设置，通常由一条机器指令完成），软件方法，信号量与P、V操作。

1. 硬件——关中断。禁止所有中断就可以屏蔽一个CPU上的进程切换。影响并发效率。
2. 硬件——testset（加锁开锁）。不断使用循环的硬件指令确认资源是否空闲，空闲则退出循环。“忙等”，浪费CPU时钟。
3. 软件——信号量PV操作

若信号量S表示某一类资源，则对S执行P、V操作的直观含意是什么? 当进程对信号量S执行P、V操作时，S的值发生变化，当S>0、S=0、和S<0时，其物理意义是什么?

1. 信号量值，代表资源数，+代表有资源，0代表资源恰好用光，-代表有进程阻塞（资源为负）。
2. P：申请资源，对应先S-1，再判断是否为负，如果初始S为0（-1后为负）则会阻塞
3. V：释放资源，对应S+1，再判断是否为负，如果+1后还是负，则说明阻塞链表中还有进程，执行唤醒。V不会导致阻塞

在用P/V操作实现进程通信时，应根据什么原则对信号量赋初值？

信号量初值=临界资源的数量

进程高级通信有哪些实现机制？

1. 消息缓冲。直接通信。
2. 信箱。间接通信。
3. 管道。两个进程之间建立一一对应管道。注意，管道和管程不同。管程不属于进程间高级通信，仅仅是中间的过渡形式，而管道是高级通信。
4. 共享主存区。用于大量数据通信。

死锁定义，产生的必要条件及解决死锁的方法

一组进程中，每个进程都在等待其他进程所占用的临界资源。

死锁必要条件，顺起来就是，临界资源，拿着不放（保持请求），别人抢不了（不可剥夺），循环等待：

1. 互斥条件
2. 保持和请求条件。进程因请求资源而阻塞时，对已经获得的资源保持不放。
3. 不可剥夺条件。
4. 循环等待条件。存在一个进程循环链，链中每个进程都在等待链中的下一个进程所占用的资源。

解决方法，以下四种方法根据时间段排序，1干脆放弃，2最早预防，3边运行边判断，4等发生了再解决：

1. 鸵鸟算法。忽略死锁。（最弱）
2. 死锁的预防。通过破坏产生死锁的四个必要条件中的一个或几个，来防止发生死锁。
3. 死锁的避免。动态预测，避免进入死锁区。经典算法为进程-轨迹资源图与银行家算法。
4. 死锁的检测和恢复。允许死锁发生。通过设置检测机构，及时检测出死锁的发生，然后采取适当措施清除死锁。

第4章 存储器管理

存储器管理的功能。名字空间、地址空间、存储空间、逻辑地址、物理地址。

功能：

1. 存储器分配：解决多进程共享主存的问题
2. 地址转换或重定位：研究各种地址变换方法及相应的地址变换机构。
3. 存储器保护：防止故障程序破坏OS和其它信息
4. 存储器扩充：采用多级存储技术实现虚拟存储器，交换技术。
5. 存储器共享：研究并发进程如何共享主存中的程序和数据。

从名字空间到储存空间：

1. 名字空间。下图中，符号名字空间就是程序中的变量名，使用符号来代替地址。
2. 地址空间。.o文件的逻辑地址从0开始，链接后的完整exe程序逻辑地址同样是从0开始，地址空间指的就是逻辑地址空间。
3. 储存空间。最后装入内存后的物理地址，储存空间指的是物理地址空间。

什么是地址重定位?分为哪两种?各是依据什么和什么时候实现的?试比较它们的优缺点。

从逻辑地址到物理地址的过程叫地址重定位/地址映射/地址变换，分两种：

1. 静态重定位。装入内存前，将程序中逻辑地址转换为物理地址。优点是实现简单，不需要额外的硬件，缺点是程序运行后就不可以再进行程序位置变动，主存利用不充分，不可共享主存。
2. 动态重定位。程序指令不做修改，通过一个重定位寄存器记录程序在内存中的偏移，程序寻址时通过寄存器进行逻辑地址转换。优点是程序可移动，主存利用充分，可以共享主存。缺点是需要额外的硬件基础。

内存划分为两大部分

用户空间和操作系统空间。存储器管理是针对用户空间进行管理的。

存储保护的目的是什么?对各种存储管理方案实现存储保护时，硬件和软件各需做什么工作?

防止数据访问出错，防止破坏数据。

TODO?

试述可变式分区管理空闲区的方法及存储区的保护方式。

1. 分区说明表
2. 空闲区链表

首先明确，固定分区采用静态重定位，可变式分区采用动态重定位。动态重定位采用限长寄存器进行保护，如果逻辑地址超出限长寄存器，就会触发异常。

覆盖与交换有什么特点？

1. 覆盖：如果程序中的两段代码不会同时执行，那么就可以让这两段代码公用一个覆盖区。覆盖执行起来很复杂。
   • 只能发生在没有调用关系的模块间
   • 程序员必须给出覆盖结构
2. 交换：将暂时不会执行的程序放到外存，等需要执行的时候再交换到内存。交换的时间成本较大。
   • 发生在进程之间
   • 不需要覆盖结构

页表的作用是什么?简述页式管理的地址变换过程。能利用页表实现逻辑地址转换成物理地址。管理内存的数据结构有哪些？

记录程序内逻辑页号到主存上物理页号的映射关系。克服了连续储存的问题。

总的来说分三步：

1. 找到页表。控制寄存器中储存了页表位置
2. 页号映射。将逻辑页号映射到物理页号，会提前判断越界中断。
3. 物理地址=页号×页面大小+页内偏移
   

管理方式：

1. 储存分块表。类似于空闲区链表，只不过块大小是固定的了
2. 位示图。一位对应一块

什么是页式存储器的内零头?它与页的大小有什么关系?可变式分区管理产生什么样的零头（碎片）？

一个程序需要的空间大概率不是页大小的整数倍，所以在最后一页中会出现没有使用的空间，即页内零头。页大小越大，越容易产生大的内零头，页大小越小，越容易产生整数倍的情况。

可变式分区的程序内部不会出现零头，但是会产生外零头，即系统无法使用的内存碎片。

段式存储器管理与页式管理的主要区别是什么?

1. 段大小不固定，页大小固定
2. 段允许动态扩充，页不可以
3. 段可以产生主存碎片，页消除了主存碎片
4. 段便于共享，便于动态链接，页只能静态链接，共享困难。

什么是虚拟存储器。虚拟存储器的容量能大于主存容量加辅存容量之和吗?

虚拟储存器是系统构造的非常大的地址空间。

理论空间可以很大，但是实际容量不可以超过主存+辅存之和。

实现请求页式管理，需要对页表进行修改，一般要增加状态位、修改位、访问位。试说明它们的作用。

1. 状态位。表示页是否在主存，1在0不在
2. 修改位。表示页是否被修改过，这涉及到置换页面后，是否需要再写回外存
3. 访问位。表示页是否被访问过，用于辅助页面置换算法。

缺页中断时机，产生缺页中断时，系统应做哪些工作?

1. 当逻辑地址查页表的时候，发现页表状态位=0，发生缺页中断。
2. 发生缺页中断后，检查有无空闲页：
   • 有空闲页，则直接从磁盘中装填。
   • 无空闲页，按照页面置换算法进行置换。此时要考虑修改位以及访问位。
3. 装填好页后，恢复被中断的指令

会利用FIFO、LRU、OPT以及时钟页面置换算法描述页面置换过程，计算产生的缺页率。Belady异常。

Belady异常指增加主存块后反而增加了缺页率。FIFO会出现，但是LRU不可能出现Belady异常。

1. OPT算法是直接找到对应页位置进行替换。
   
2. FIFO算法会对页面对列进行整体下移。
   
3. LRU在FIFO的基础上，会将最近使用的页提升到最上面
   
4. clock算法和OPT一样，都是直接原位替换。但是clock算法新增引用位，发生S后，会重置引用位，相当于一次免死金牌。注意，发生F且置换后，指针停留在新页面的下一位。
   

什么是程序的局部性原理？什么叫系统抖动?

1. 时间局部性。程序有很多循环，会在一段时间内重复执行一部分
2. 空间局部性。顺序执行的代码中，地址域不会迅速变化。

系统抖动：一个频繁使用的页面被频繁地交换。拖慢进程运行速度。

多级页表的概念，多级页表中页表建立的时机。写时复制技术的概念。

使用二级页表来映射一级页表所在的页。当一级页表无法索引所有的页时建立二级页表。

如果某一个进程像共享的主存页写时，就会将这一页复制一份并更新这一进程的页表。

页的共享问题。

需要一个专门数据结构来记录进程间共享页。使用原型页表（详见Windows中的区域对象）。

第5章 文件系统

什么是文件和文件系统? 文件系统的主要功能。UNIX系统如何对文件进行分类？它有什么好处？

文件：储存在外存的，具有符号名的，信息集合
文件系统：文件管理的整个软件体系，包括管理软件，对应的数据结构，以及被管理的文件。

功能：

1. 实现按名存取，目录层次
2. 管理文件储存器，实现空间监控，分配，回收
3. 具有灵活多样的文件结构和存取方法。
4. 保证文件的安全性，便于文件共享

UNIX文件分类：

1. 普通文件
2. 目录文件
3. 特殊文件（比如IO设备）。

UNIX文件的特殊文件使用接口与普通文件无异，非常方便。

文件目录的作用是什么?文件目录项通常包含哪些内容? 文件控制块。

注意，文件目录对应FCB。所谓的目录文件，里面储存的是文件目录表，和文件目录是所属关系。

文件目录对应一个FCB块，记录了文件的元数据，便于文件管理组织。FCB中通常包含了文件名，类型，位置，大小，保护方式等信息。

文件的逻辑结构有几种形式？文件的存取方法？

两种：

1. 无结构字节流文件
2. 有结构的记录文件，比如txt

存取：

1. 顺序读取
2. 随机读取

文件的物理结构有哪几种?对于不同的结构，文件系统是如何进行管理的?

1. 连续文件。目录表中，记录文件起始与长度
2. 链接文件。目录表中，同样记录起始和长度，但是物理块是按照链接组织的，前一个物理块中储存下一个物理块的块号。只能顺序读取。
3. （可选：内存中一张大索引表）。将所有物理块的链接表一次性存到内存中，是一种过渡思路。
4. 索引文件。目录表中，记录索引文件块号与长度。用一个物理块存文件索引，第一次读取先把索引读入内存，第二次就可以随机读取文件物理块。
5. 索引顺序文件。考虑到了连续储存的情况，增加了簇数一列。

不同操作系统使用的文件卷结构？

1. DOS采用古老的链接结构
2. Linux的Ext2采用多级索引文件
3. Windows的NTFS采用索引顺序文件

了解记录的组块和分解

这两个概念都是针对小文件的。

1. 组块。可以把多个小文件放在一个物理块中。物理块中的文件数就是物理块的块因子
2. 分解。读取一个小文件前，要先读物理块，一次性读出若干小文件，再将目标小文件分解出来。

文件存储空间的管理方法有几种?它们各是如何实现文件存储空间的分配和回收的?

常用的对磁盘存储空间的管理方法：

1. 空白文件目录（空闲块表法 ，是一种最简单的方法）。分配与回收通过增删，修改文件目录项实现。
2. 空闲块链表（进阶为空闲块成组链表）。增删链表节点。
3. 位映像表(bit map)或位示图。修改bit位

建立多级目录有哪些好处?文件的重名和共享问题是如何得到解决的?

文件组织更加层次化，便于管理。
即使重名，只要在不同的目录中，绝对路径也不相同。
共享可以通过硬链接共享，或者符号链接（软链接）。

文件系统中，常用的文件操作命令有哪些？它们的具体功能是什么?打开和关闭文件命令的目的是什么?

1. 创建/删除。本质上是增删目录项
2. 打开/关闭。创建文件对象，添加到进程的文件对象链表中。
3. 读/写/追加。操作文件内容，同时修改目录项中的大小记录。

存取控制表ACL的概念。

ACL是存取控制表，脱胎于存取控制矩阵，存取控制矩阵是储存保护域的数据结构。

每一个文件都有一个ACL，记录了不同保护域对当前文件的权限。

理解内存映射文件（memory mapped file）的过程。

1. 首先要有一个磁盘对象。可以创建或者打开，CreateFile
2. 建立区域对象。区域对象是公用的，CreateFileMapping
3. 在进程中映射区域对象。MapViewOfFile
4. 访问结束后解除映射。UnMapViewOfFile

第6章 设备管理

I/O设备通常大致可分为哪两大类？各自传输的信息单位有什么特点？

按照传输单位分：

1. 字符设备。以字符为单位传输信息。通信速度慢，且只能顺序读写
2. 块设备。以块为单位传输信息。通信速度快，可以寻址，即可以随机读写某一块

常用的四种数据传输方式。

1. 程序查询方式（pooling）。由CPU完成IO，且CPU不断查询确认IO是否可用
2. 中断方式。由CPU完成IO，但是确认IO可用是通过中断实现的，在此之前，CPU可以干别的。
3. 直接储存器访问（DMA）方式。由DMA完成IO，CPU只需要初始化与验收结果。
4. 通道控制方式。DMA只能控制一个IO，通道可以控制多种多个IO。

根据设备的使用方式，设备被分为几种类型？何为虚拟设备？它是通过什么技术实现的？

按照使用方式：

1. 储存设备。比如磁盘，容量大，响应时间长。
2. 输入输出设备。比如键盘，鼠标，响应快。

一个设备本身是独占设备，但是可以当做虚拟的共享设备用。需要Spooling技术实现。

按照设备管理的层次结构，I/O软件划分为几层？各层主要实现哪些功能？

1. 用户IO接口。包括图形界面以及库函数。
2. 设备独立层。设备命名，统一块尺寸，IO缓存技术
3. 设备驱动层。为不同类型的硬件设备提供类似的接口
4. 中断处理层。处理设备中断。

何为设备的独立性？

设备独立性是指用户及用户程序不受系统配置的设备类型和具体设备的台号的影响。用户只是使用逻辑设备，具体的映射由操作系统完成。

什么是SPOOLING技术？以输出为例，说明它的实现原理。

SPOOLING技术是以空间换时间的虚拟设备技术。

以打印输出为例，系统先把不同进程要打印的数据缓冲到一个磁盘文件上，形成待打印文件队列。之后Spooling系统将队列中的文件逐个送到打印机打印。

一个特定磁盘上的信息如何进行编址？

1. 古老方法：盘面号、磁道号 和扇区号
2. 一排磁头共进退：柱面号、磁头号和扇区号

第7章 Linux进程管理

进程控制块，其中与进程管理、存储器管理和文件管理有关的一些字段，线程组标识符。

linux中的PCB是tast_struct结构体：

1. thread_info，进程基本信息。
2. mm_struct指向虚拟内存
3. files_struct指向打开文件的结构，
4. tgid，线程组的id。

与进程创建有关的函数：fork( )、vfork( )、clone( )。

1. fork。采用写时复制技术，复制全部资源，根据返回pid判断是否是子进程，不阻塞。
2. vfork。共享资源，且阻塞父进程。
3. clone。轻量级进程函数，用于实现Linux线程，可以选择共享哪些数据。

理解进程切换的过程。涉及到页目录表、核心栈、硬件上下文。

1. 需要先将小部分用户态寄存器信息保存，送到核心栈
2. 大部分寄存器（硬件上下文）被送到PCB里。具体是thread_struct 的 thread字段
3. 前两部都是用户态，最后通过核心态进行进程切换，先切页目录表（换一个页目录段，换一个页表TODO），再切核心栈与硬件上下文（恢复寄存器）

进程调度方式。进程调度时机。

通过动态优先级进行调度。进程调度类型：

1. 先进先出的实时进程，时间片轮转的实时进程。基本优先数为1～99，优先级较高，费时较少
2. 普通的分时进程。分时进程和批处理进程的基本优先数为100～139

实时进程调度时机：

1. 被抢占了。出现了更高优先级的实时进程
2. 走不动了。进程执行了阻塞操作，或者干脆停止运行或被杀死
3. 自愿放弃。进程调用了sched_yield()自愿放弃处理机
4. 轮转的实时系统中，时间片用完。

Linux有很多内核线程，了解0号进程和1号进程的作用。

内核没有进程一说，资源全是共享的，所以是内核线程。

1. 0号进程是一切进程的根。0号进程就是一个内核线程，0号进程是所有进程的祖先进程，又叫idle进程或叫做swapper进程。每个CPU都有一个0号进程。
2. 1号进程（init）是用户态进程的根。是由0号进程创建的内核线程 init，负责完成内核的初始化工作。在系统关闭之前，init进程一直存在，它负责创建和监控在操作系统外层执行的所有用户态进程。
3. 2号进程（kthreadd）负责创建内核线程。

第8章 Linux存储器管理

进程地址空间的划分？管理进程私有地址空间的数据结构？

3G用户空间，1G内核空间，对应物理内存前1G，这1G分为两段，后半段128M为固定的特殊分区。

mm_struct是虚拟段页式管理的总结构。其一边指向虚拟段结构（mmap，mm_rb），每一个vm_area_struct对应一个段，vm_area_struct之间以单链表和红黑树两种结构进行组织。另一边指向页结构（pgd），为页目录表，页表，物理页的结构。

Linux堆的管理：

1. malloc/free
2. new/delete

管理物理内存页框的数据结构？内存管理区zone结构？伙伴系统？了解分区页框分配器分配页框的过程。

struct page，其中有一个字段是物理页框号，所以page与物理页一一对应，尤其注意private字段，会在伙伴系统中用到。

4G的虚拟内存，从页的角度上，被分成3个zone，1个DMA zone，用于兼容老系统，1个normal zone，用于内核访问，剩下的大量空间归为zone_highmem区。zone结构记录了一个内存分区的整体使用情况，比如空闲页框数。zone结构中还有一个重要的部分：free_area，与伙伴系统有关。

分区页框分配器用于记录连续页框，free_area长度为11，分别对应2的0-10次方长度的连续页框，page结构中的private字段就是幂值。伙伴系统用于分配与回收连续页框：

1. 分配：大切小，一部分小的拿去用，另一部分小的降级
2. 回收：小合大，大的升级。

理解slab分配器的原理。slab分配器的作用？

slab分配器用于比页框更细粒度的内存分配。
slab分配器先批发一些连续页框，常住内存，形成高速缓冲区，之后在高速缓冲区中进行细粒度分配。

进程页表建立的时机？了解页目录表项或页表项所包含的字段。逻辑地址的划分，利用两级页表实现地址转换的过程。

懒惰原则：进程启动时不会创建页表，等开始访问页的时候才建立页表

页表项，除了20位地址，就是经典的3个位：标志位（present），访问位（accessed），写位（dirty）

逻辑地址分为10位页目录选择，10位页表选择，12位页内偏移。

1. PDBR中的页目录基址（20位）+页目录索引×4得到页表描述符。
2. 从页表描述符中取前20位（前5个16进制数）基址+页表索引×4可得页描述符
3. 从页描述符再取20位基址+页内索引=物理地址。注意业内索引不用乘，因为一个页内索引只对应1字节。

请求调页。所缺的页可能存放的地方。

1. 没访问过，在交换区以外的外存区域。该页从未被进程访问过，在交换区以外的外存区域，没有相应的内存映射。
2. 访问过，但被交换到交换区了。该页已被进程访问过，但其内容被临时保存到磁盘交换区上。
3. 休眠中，在非活动页框链表中。
4. 被锁了。该页正在由其它进程进行I/O传输过程中，这种只能阻塞。

了解盘交换区空间的管理方法。

盘交换区虽然在磁盘，但是却要像内存一样构造，由若干页槽组成，页槽大小和内存的页大小对应，为4K。

盘交换区可以是一个swap分区，也可以一个磁盘文件。

第9-10章 Linux文件系统

Ext2文件卷的布局？各部分的作用是什么？

最顶层进行分区，每个分区有若干个磁盘块组，对于每个块组有如下信息：

1. 超级块。描述磁盘整体信息，每个块组的超级块都一样。
2. 块组描述符。有k块，其实只需要1块就可以描述本块组。其他的有数据冗余，用于备份
3. 数据块位图，索引节点位图。位示图描述索引节点和数据块的占用情况。
4. 索引节点区，数据块区。这是真正存索引和数据的区域。

Linux系统把一般的文件目录项分成哪两部分？这样做的好处是什么？

每个文件目录项被拆分成两部分：

1. 索引节点。即inode
2. 简单目录项。inode号以及文件描述信息

查找文件只需要在文件目录里查找简单目录项里找即可，查找速度快。之后再用inode号去索引inode，效率高。

Linux文件系统的索引节点中，索引表划分成几级？文件的索引表是如何增长的？要求能够利用索引表实现将文件中的字节地址转换成文件的物理块的操作。

直接索引与三级间接索引。在将逻辑地址转换为物理块的时候，通过逻辑地址区间判断是几级索引，进而计算出具体的物理块。

15个元素的数组，其实就是索引表。我们捋一下多级索引，假设一个盘块的大小为b，则满打满算，只储存块索引，可以存$\frac{b}{4}$个索引。

1. 0-11索引号是直接索引。数值本身就是物理块号，对应逻辑上0-11的块
2. 12号是一次索引。经过一次索引，一个索引块可以储存$\frac{b}{4}$个索引，所以一次索引的区间长度就是$\frac{b}{4}$，所以其对应逻辑块区间为：12到$\frac{b}{4}$+11
3. 13号是二次索引。二次索引，可以储存的区间长度为$(\frac{b}{4}{)}^2$，所以其对应逻辑块区间为：$\frac{b}{4}$+12到$\frac{b}{4}$+$(\frac{b}{4}{)}^2$+11
4. 14号是三次索引。以此类推，区间长度为$(\frac{b}{4}{)}^3$，所以逻辑块号区间为$\frac{b}{4}$+$(\frac{b}{4}{)}^2$+12到$\frac{b}{4}$+$(\frac{b}{4}{)}^2$+$(\frac{b}{4}{)}^3$+11

硬链接和符号链接的区别？

1. 硬链接，通过简单目录项中的inode号建立直接指向关系，将所有硬链接删除后会删除inode
2. 符号链接储存绝对路径，删除符号链接不会影响源文件。

Linux文件系统如何管理空闲存储空间？

块组描述符和超级块中有空闲块相关的数据记录。

VFS通用文件模型中的四个主要对象？

VFS系统建立在磁盘文件系统之上，其4种数据结构都在内存，独立于磁盘文件系统，即下面这4个对象：

1. 对于一个文件系统，建立一个超级块对象。和上一章学到一个超级块是一样的级别（只不过在内存中）
2. 索引节点对象。对应inode，与文件一一对应。
3. 目录项对象（dentry）。对应磁盘的简单目录项，可以多个目录硬链接到一个inode
4. 文件对象。一个进程可以打开一个文件对象，可以多个文件对像对应一个目录项对象。

Linux系统中，进程打开一个磁盘文件要涉及哪些数据结构？了解：它们各有哪些关键字段？他们的作用是什么？

数据结构，除了PCB和内存中的inode信息，其他4个对应上面4个对象。

1. task_struct:PCB
2. files_struct:进程打开的所有文件
3. file:进程打开的一个文件结构
4. dentry:文件结构指向的文件目录项
5. inode:文件目录项硬链接到的inode
6. ext2_inode_info：内存中的inode信息

一个文件在使用与不用时各占用系统哪些资源？

不使用时，占用磁盘资源。
使用时，还要额外占用内存资源，存放VFS相关的4种对象。

安装表的作用是什么？

用于记录VFS中安装的系统。主要信息为安装的系统信息与安装点。

第14章 Windows操作系统模型

Windows 采用什么样的体系结构？

从上往下：

1. 用户态
2. 执行体（负责不同模块的核心工作）
3. 内核
4. 硬件抽象层（HAL）
   

硬件抽象层HAL的作用是什么？

将对不同硬件的操作抽象成统一的接口，使得操作系统内核免受硬件平台的影响。

Windows中有哪些对象，都有什么作用？

执行体和内核是概念上的东西，具体在操作系统中实现是以对象的形式存在的：

1. 执行体对象：封装了内核对象的一部分，执行操作系统不同模块的功能，比如进程调度，内存管理，储存器管理，文件系统。
2. 内核对象：若干对象构成一个集合，提供基本的内核功能，仅供执行体使用。内核对象分为两类：
   • 控制对象。仅仅控制内核，不改变进程调度。包括内核进程对象，APC，DPC，中断对象等
   • 调度程序对象，又名分发器对象 dispatcher object，改变进程调度。包括内核线程，事件对象，互斥体，信号量，定时器等等。之所以调度程序对象又名分发器对象，是因为这些对象都有一个共通的数据结构头：DISPATCHER_HEADER结构。

Windows系统组件的基本机制？

1. 陷阱调度。Windows内核大量使用的中断就是陷阱调度的一种，这是内核的功能。具体包括中断、DPC 、APC 、异常调度、系统服务调度。
2. 执行体对象管理器。执行体里面有一个对象管理器，负责管理各种核心态中的对象。
3. 同步。比如多个CPU之间的同步。使用的技术为自旋锁、内核调度程序对象。
4. 本地过程调用LPC。服务器进程创建一个LPC连接端口对象，然后在该端口上监听客户连接请求。类似socket编程。消息传递。

理解：延迟过程调用DPC，异步过程调用APC

下图为中断优先级表。

通常，一个任务会有重要的部分和不重要的部分，重要的部分会产生硬件中断，优先执行。而其余耗时的，不那么重要的（但是仍然很重要），会产生DPC软件中断，等硬件中断都处理完了，再处理DPC任务。这就是延迟调用。

DPC队列是全局的，而APC队列是局部的，在进程调度切换到某一进程时，该进程首先执行APC队列里的内容。所以APC经常用于异步IO通信。

对象管理器机制如何实现？

对象分为对象头和对象体。对象头中有指向类型对象的指针。类型对象规定了某一类对象的公有属性。

在多处理机系统中，提供了哪些同步和互斥机制？

1. 内核（互斥）。引入自旋锁实现多CPU互斥机制。底层是testset，具有绝对优先级，不可剥夺。
2. 执行体。执行体对象有控制对象和调度程序对象。调度程序对象很多，你只需要记住他们都会影响程序调度就行了。每个同步对象都有“有信号”或“无信号”两种状态，通过WaitForSingleObject函数实现同步。

第15章 Windows 进程和线程管理

管理进程和线程的数据结构？

1. 执行体进程块EPROCESS、执行体线程块ETHREAD
2. 内核进程块KPROCESS、内核线程块KTHREAD。

创建进程和线程

1. CreateProcess( )
2. CreateThread( )

线程的7种状态，及其解释。

就绪态，运行态，阻塞态是进程的基本状态。进程还有创建态和终止态。对于线程，增加了2个更加细化的状态：备用态，传输态。

1. 初始化状态(Initialized)。
2. 就绪状态(ready)。资源已占用，等待CPU
3. 备用状态(standby)。资源已占用，CPU已选好，正等待描述表切换，以便进入运行状态。
4. 运行状态(Running)。资源和CPU都占用。
5. 等待状态(waiting)。其实就是阻塞态。
6. 传输状态(transition)。特殊的阻塞态，等待的资源在外存，正在等待传输。
7. 终止状态(terminated)。
   

线程调度机制？线程调度用到的数据结构？

基于优先级的抢先式的多处理机调度系统。线程调度程序的数据结构有：

1. 32个就绪队列。每个优先级对应一个。
2. 32位掩码的就绪位图。每一位指示一个优先级就绪队列中是否有线程等待运行。
3. 32位掩码的空闲位图。每一位指示一个处理机是否处于空闲状态。

线程优先级的提升时机。

线程优先级提升，用于防止线程饥饿问题。本质上来说，优先级提升就是下面的情况：

1. 等待完毕。
2. 线程要执行重要部分的时候（线程有不重要部分，比如IO，有重要部分，比如处理，计算）
3. 用户要处理某个GUI窗口，操作系统应当尽力满足用户需求。
4. 线程饥饿了，不得不提升了。

第16章 Windows 存储器管理

两种数据结构：虚拟地址描述符VAD、区域对象，这两种结构各有什么作用？

和Linux中的vm_area_struct类似，Windows采用VAD描述一段虚拟内存空间，若干个VAD构成平衡二叉树，一个平衡二叉树对应一个进程的私有地址空间。

区域对象其实就是内存映射文件，区域对象本身是磁盘文件，但是在内存中有映射，像内存一样使用，且可以共享：

1. 首先要有一个磁盘对象。可以创建或者打开，CreateFile
2. 建立区域对象。区域对象是公用的，CreateFileMapping
3. 在进程中映射区域对象。MapViewOfFile
4. 访问结束后解除映射。UnMapViewOfFile

虚拟内存区域状态

私有空间的地址，有可能有三种状态：

1. 空闲的。这一块私有空间地址还没使用
2. 被保留。还没用，但是被预留，后面会用
3. 被提交。用了，可能是分配了物理主存，也可能是分配了交换区的空间。

32位逻辑地址，二级页表。页目录表项和页表项具有相同的数据结构，该数据结构包含哪些数据项？进程页表建立的时机。进程的地址转换过程。

同Linux

管理物理内存的数据结构：页框数据库。页框的8种状态：活动、转换、备用、更改、更改不写入、空闲、零初始化、坏，页框的状态转换图

页框的描述符构成一个大数组，即页框数据库。

页框描述符里对页框的状态有8种界定：

1. 活动（有效）：是某个进程工作集的一部分。
2. 转移 （正在置换淘汰）：不在工作集中，但页的内容还未被破坏，正处于I/O操作进行中，进程直接用新的页，旧的写回工作交由操作系统
3. 备用：已不属于工作集，但是可能还要用（做缓冲防止抖动）
4. 更改：已不属于工作集，修改未写磁盘，可能还要用（修改了，且备用）
5. 更改不写入 ：更改但不写入磁盘。虽然修改了，但是一会还要继续写（避免反复写磁盘）。
6. 空闲 ：不属于任何一个工作集
7. 零初始化 ：清零的空闲页框（防止一些恶意进程利用未清零的页框数据）
8. 坏页框

原型页表

虚拟页式中，采用原型页表实现多进程共享页。

进程不会直接访问区域对象中的页，而是访问建立在区域对象上的原型页表。当区域对象用于共享的时候，其在内存中是使用原型页表进行组织的，原型页表与普通页表的本质差异就在于原型页表可以轻松地向物理块转换，充当内存与物理块之间的介质。

Windows采用的页调度策略是什么？置换策略是什么？

调度：局部性调页。不仅仅调所缺页，还调这一页附近的页同时装入主存

置换策略：多处理器系统使用FIFO，单处理器使用LRU（ppt上说又叫时钟页面置换算法？tmd，clock和LRU不一样吧TODO）。注意区分，Linux使用的是LFU，Windows使用LRU。F对应Frequency，要替换最小频率访问的页，而R是Recently，要替换最近没有被访问的页。

第17章 Windows 文件系统

Windows所支持的文件系统类型有哪些？

1. FAT12，16，32。数字是描述磁盘块簇地址用的位数
2. NTFS。规定可用64位簇编号，实际限制32位。

虚拟簇号和逻辑簇号的概念。

1. 逻辑簇号LCN：类似于盘块号，对分区内的第一个簇到最后一个簇进行编号，NTFS使用逻辑簇号对簇进行定位。
2. 虚拟簇号VCN：将文件所占用的簇从开头到尾进行编号的，虚拟簇号连续，但是其对应的逻辑簇号不要求在物理上是连续的。

NTFS卷的结构，主控文件表MFT的作用。

1. 引导区里面有MBT结构，规定了卷的布局，引导代码位置
2. MFT存放元数据。
3. 数据区放数据。

NTFS文件的物理结构

索引顺序结构。

大目录储存方式

采用B+树，使得查找一个特定文件的访盘次数减到最少。（大目录文件的索引根属性包含B+树的第一级并指向包含下一级的索引缓冲区。）文章来源地址https://www.toymoban.com/news/detail-773869.html

到了这里，关于北京理工大学操作系统复习——习题+知识点的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！