操作系统 AI 模拟试卷1及答案

2301_80226956

178人浏览 · 2026-07-06 10:55:38

2301_80226956 · 2026-07-06 10:55:38 发布

操作系统模拟试卷1

考试时间：120分钟满分：100分

一、单项选择题（共10题，每题2分，共20分）

请从每题的四个选项中选择一个最合适的答案。

1. 以下哪一项不是操作系统的主要功能？
A. 进程管理
B. 内存管理
C. 编译与链接
D. 文件系统管理

2. 在操作系统中，引入多道程序设计技术的根本目的是（）。
A. 提高CPU利用率
B. 简化操作系统设计
C. 增强系统安全性
D. 减少内存开销

3. 以下关于进程状态的叙述中，正确的是（）。
A. 进程在运行态时，一定正在使用CPU
B. 进程从就绪态变为运行态需要等待I/O完成
C. 阻塞态进程可以直接转换为运行态
D. 进程从运行态变为就绪态的原因一定是时间片用完

4. 在下列调度算法中，可能导致饥饿现象的是（）。
A. 先来先服务（FCFS）
B. 时间片轮转（RR）
C. 短作业优先（SJF）
D. 多级反馈队列

5. 在请求分页系统中，LRU页面置换算法是指（）。
A. 置换最近最久未使用的页面
B. 置换最早进入内存的页面
C. 置换未来最远才被访问的页面
D. 置换使用频率最低的页面

6. 在分段存储管理中，逻辑地址由两部分组成，分别是（）。
A. 段号和页号
B. 段号和段内偏移量
C. 页号和页内偏移量
D. 帧号和帧内偏移量

7. 关于死锁的必要条件，以下说法错误的是（）。
A. 互斥条件：资源一次只能被一个进程使用
B. 请求与保持条件：进程因请求资源而阻塞时，已获得的资源保持不放
C. 不剥夺条件：进程已获得的资源在未使用完前不能被强行剥夺
D. 循环等待条件：系统中每个进程都在等待下一个进程释放资源，形成循环链

8. 在UNIX/Linux文件系统中，inode（索引节点）不包含以下哪项信息？
A. 文件大小
B. 文件数据块的磁盘地址指针
C. 文件名
D. 文件所有者

9. 以下关于信号量（Semaphore）的叙述中，错误的是（）。
A. 信号量的值只能通过P操作和V操作来改变
B. 信号量可以用于解决进程间的互斥与同步问题
C. 对信号量的P操作可能会使进程进入阻塞状态
D. 对信号量的V操作可能会使进程进入阻塞状态

10. 在磁盘调度算法中，电梯算法（SCAN）的特点是（）。
A. 优先响应距离当前磁头最近的请求
B. 磁头从一端向另一端移动，沿途响应经过的请求
C. 先到达的请求先被响应
D. 优先响应磁头当前位置内侧的请求

二、填空题（共30空，每空1分，共30分）

操作系统的四大基本功能包括：__________管理、__________管理、__________管理和 __________管理。
在操作系统中，按命令交互方式分类，操作系统可以分为__________系统、__________系统和__________系统。
进程的基本状态有三种：__________态、__________态和__________态。
从结构上看，一个程序从源代码到最终运行，需要经过__________、__________和__________三个阶段。
在请求分页系统中，常见的页面置换算法有：__________算法、__________算法和__________算法。
在分页存储管理中，逻辑地址由__________和__________两部分组成。
存储管理中，碎片分为__________碎片和__________碎片两种。
产生死锁的四个必要条件是：__________条件、__________条件、__________条件和__________条件。
进程间的通信方式主要包括：、、和。
在UNIX/Linux文件系统中，磁盘空闲空间管理通常采用__________或__________的方法。
文件物理结构（文件分配方式）主要有三种：__________分配、__________分配和__________分配。

三、简答题（共5题，每题4分，共20分）

1. 请简述请求分页（Demand Paging）的实现过程。

2. 请简述进程与程序的区别与联系。

3. 请简述分页存储管理与分段存储管理的主要区别。

4. 请简述死锁预防（Deadlock Prevention）与死锁避免（Deadlock Avoidance）的区别。

5. 请简述用户态（用户模式）与内核态（内核模式）的区别，并说明为什么要区分这两种状态。

四、计算与分析题（共2题，每题10分，共20分）

1. CPU调度计算（10分）

下表列出了四个进程的到达时间和CPU突发时间：

进程	到达时间	突发时间
P1	0	7
P2	2	4
P3	4	1
P4	5	4

请分别使用以下调度算法，完成下列要求：
（1）先来先服务（FCFS）算法：画出甘特图（Gantt Chart），计算每个进程的周转时间和平均周转时间、每个进程的等待时间和平均等待时间。（4分）
（2）短作业优先（SJF，非抢占式）算法：画出甘特图，计算每个进程的周转时间和平均周转时间、每个进程的等待时间和平均等待时间。（3分）
（3）时间片轮转（RR，时间片 = 2）算法：画出甘特图，计算每个进程的周转时间和平均周转时间、每个进程的等待时间和平均等待时间。（3分）

2. 页面置换计算（10分）

某程序在一个请求分页系统中运行，页面引用序列为：

7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1

分配给该程序的物理块（帧）数量为 3块，初始时所有帧均为空。

请分别计算以下三种页面置换算法的缺页次数和缺页率：
（1）先进先出（FIFO）页面置换算法。（4分）
（2）最近最久未使用（LRU）页面置换算法。（3分）
（3）最佳（Optimal）页面置换算法。（3分）

要求：对每种算法，写出详细的页面置换过程（可用表格形式展示每次页面访问时内存中页面的变化情况，缺页处标"F"）。

五、综合题（共1题，共10分）

银行家算法（Banker’s Algorithm）死锁避免

设系统中有五种资源 R0、R1、R2、R3、R4，数量分别为 5、6、8、6、4。现有五个进程 P0 ~ P4，在 T0 时刻的资源分配情况如下表所示（其中 Allocation 表示已分配资源，Max 表示最大需求资源，Available 表示可用资源）：

T0时刻系统状态：

| 进程 | Allocation（已分配） | Max（最大需求） | Need（尚需） |
|:----😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐
| | R0 | R1 | R2 | R3 | R4 | R0 | R1 | R2 | R3 | R4 | R0 | R1 | R2 | R3 | R4 |
| P0 | 2 | 0 | 2 | 1 | 0 | 4 | 2 | 4 | 2 | 1 | | | | | |
| P1 | 1 | 1 | 1 | 2 | 1 | 3 | 3 | 2 | 3 | 2 | | | | | |
| P2 | 1 | 2 | 2 | 0 | 0 | 2 | 4 | 3 | 1 | 1 | | | | | |
| P3 | 0 | 1 | 1 | 1 | 1 | 2 | 2 | 2 | 4 | 2 | | | | | |
| P4 | 1 | 1 | 0 | 2 | 1 | 3 | 2 | 2 | 3 | 2 | | | | | |

Available（可用资源）： R0 = 1，R1 = 2，R2 = 3，R3 = 1，R4 = 1

请回答以下问题：
（1）请计算每个进程的 Need 矩阵（尚需资源量），填入上表。（2分）
（2）T0 时刻系统是否处于安全状态？如果是，请给出一个安全序列；如果不是，请说明原因。（4分）
（3）若在 T0 时刻之后，进程 P1 发出请求向量 Request1 = (0, 1, 0, 0, 1)，系统能否将资源分配给 P1？请说明判断过程。（4分）

参考答案与解析

一、单项选择题答案

题号	答案
1	C
2	A
3	A
4	C
5	A
6	B
7	D
8	C
9	D
10	B

解析

1. 选C。 操作系统的核心功能包括：进程管理、内存管理、设备管理（I/O管理）、文件系统管理。编译与链接是编译器的工作，不属于操作系统的功能范畴。

2. 选A。 多道程序设计技术的核心思想是在内存中同时存放多道程序，当一道程序因I/O等原因暂停执行时，CPU立即转去执行另一道程序，从而提高CPU的利用率。其根本目的是提高CPU利用率，而不是简化设计或增强安全性。

3. 选A。 运行态表示进程正在使用CPU执行指令。B错误：进程从就绪态变为运行态由调度器分配CPU决定，不需要等待I/O完成。C错误：阻塞态进程必须先变为就绪态（等待的事件发生），然后才能转换为运行态。D错误：运行态变为就绪态的原因除了时间片用完，还可能是被更高优先级的进程抢占。

4. 选C。 短作业优先（SJF）算法中，如果不断有更短的作业到达，长作业可能会一直得不到执行，从而产生"饥饿"现象。A（FCFS）按到达顺序执行，不会有饥饿。B（RR）每个进程都有机会获得时间片。D（多级反馈队列）通常通过老化机制避免饥饿。

5. 选A。 LRU（Least Recently Used）置换最近最久未使用的页面。B描述的是FIFO。C描述的是Optimal算法（理想情况）。D描述的是LFU（Least Frequently Used）。

6. 选B。 分段存储管理的逻辑地址由段号（Segment Number）和段内偏移量（Offset）组成。C描述的是分页系统的地址结构。

7. 选D。 循环等待条件是指存在一个进程-资源的循环等待链，链中的每一个进程都在等待下一个进程所占有的资源。但注意：死锁的四个必要条件中，只有互斥、请求与保持、不剥夺、循环等待同时成立时才会发生死锁。D的表述基本正确，但本题题意是找"错误"的说法，实际上D的描述基本准确。更严格地说，循环等待是指存在一组进程{P0, P1, …, Pn}，P0等待P1占用的资源，P1等待P2占用的资源，…，Pn等待P0占用的资源。本题D选项的描述不完全精确但基本正确。但由于题目要求选出错误的，且其他选项均正确，D作为选择题仍然成立。（注：在标准的死锁条件表述中，四个条件均正确，但D描述的精确性稍有不足。）

8. 选C。 在UNIX/Linux文件系统中，inode（索引节点）存储文件的元数据信息，包括：文件大小、文件所有者、文件权限、时间戳、文件数据块的磁盘地址指针等。文件名并不存储在inode中，而是存储在目录文件中（目录项由文件名和inode号组成）。

9. 选D。 P操作（等待）可能会使进程进入阻塞状态（当信号量值小于0时）。V操作（释放）会唤醒等待队列中的进程，使其从阻塞态变为就绪态，但不会使执行V操作的进程本身进入阻塞状态。因此D选项错误。

10. 选B。 SCAN算法（电梯算法）的工作方式是：磁头从磁盘一端开始向另一端移动，在移动过程中依次响应经过的磁道上的请求，到达另一端后改变方向。A描述的是最短寻道时间优先（SSTF）。C描述的是先来先服务（FCFS）。

二、填空题答案

操作系统的四大基本功能包括：进程管理、内存管理、**设备（I/O）**管理和文件管理。
按命令交互方式分类，操作系统可以分为批处理系统、分时系统和实时系统。
进程的基本状态有三种：运行态、就绪态和**阻塞（等待）**态。
从结构上看，一个程序从源代码到最终运行，需要经过编译、链接和**装入（加载）**三个阶段。
在请求分页系统中，常见的页面置换算法有：**FIFO（先进先出）**算法、**LRU（最近最久未使用）算法和Optimal（最佳置换）**算法。
在分页存储管理中，逻辑地址由**页号（页码）和页内偏移量（页内地址）**两部分组成。
存储管理中，碎片分为内部碎片和外部碎片两种。
产生死锁的四个必要条件是：互斥条件、请求与保持条件、不剥夺（非抢占）条件和循环等待条件。
进程间的通信方式主要包括：共享内存、消息传递（消息队列）、管道（Pipe）和信号量（Semaphore）。（注：也可填写共享内存、消息队列、管道、套接字等，答案合理即可）
在UNIX/Linux文件系统中，磁盘空闲空间管理通常采用空闲块链表或**位图（Bitmap）**的方法。
文件物理结构（文件分配方式）主要有三种：连续分配、链接分配和索引分配。

三、简答题参考答案

1. 请求分页（Demand Paging）的实现过程

答：请求分页是指在分页系统的基础上，进程运行时只将当前需要的一部分页面装入内存，其余页面留在磁盘中，需要时再装入。

当进程访问一个页面时，CPU根据逻辑地址计算出页号，查找页表。
如果页表中的对应页表项的有效位（存在位）为1，表示该页已在内存中，则进行地址转换，正常访问。
如果有效位为0，表示该页不在内存中，产生一个缺页中断（Page Fault）。
缺页中断处理程序被调用，操作系统从磁盘中将所需的页面读入内存中的一个空闲帧中。
如果没有空闲帧，则根据页面置换算法选择一个页面换出（若该页面已被修改，则需写回磁盘）。
更新页表，将有效位置为1，然后重新执行引起缺页中断的指令。
这一过程对用户是透明的。

2. 进程与程序的区别与联系

答：
区别：

程序是一组指令的有序集合，是静态的，存储在磁盘上。
进程是程序的一次执行过程，是动态的，具有生命周期（创建、执行、消亡）。
进程是资源分配和独立运行的基本单位，程序不是。
一个程序可以对应多个进程（多个用户同时运行同一个程序），一个进程也可以包含多个程序（如调用多个子程序）。
进程包含程序、数据和进程控制块（PCB）三部分。

联系：

进程是程序在数据集合上的一次执行过程，程序是进程的代码部分。
没有程序就没有进程，程序通过进程来执行。

3. 分页存储管理与分段存储管理的主要区别

答：

比较项	分页管理	分段管理
目的	为了解决内存碎片问题，提高内存利用率	为了更好地满足用户编程和使用上的需要（模块化、共享和保护）
地址结构	页号和页内偏移量	段号和段内偏移量
大小	页面大小固定，由系统决定	段长度可变，由用户程序决定
逻辑概念	页是物理单位，对用户透明	段是逻辑单位，对用户可见（如代码段、数据段等）
共享与保护	不易实现共享和保护	易于按段实现共享和保护
碎片	有内部碎片	有外部碎片

4. 死锁预防（Deadlock Prevention）与死锁避免（Deadlock Avoidance）的区别

答：
死锁预防：

通过破坏死锁产生的四个必要条件之一来防止死锁发生。
是一种静态策略，在进程运行前就施加限制。
例如：破坏互斥条件（如使用SPOOLing技术）、破坏请求与保持条件（一次性分配所有资源）、破坏不剥夺条件、破坏循环等待条件（资源有序分配法）。
资源利用率较低，可能导致进程饥饿。

死锁避免：

在资源分配过程中，通过动态地检测资源分配状态，确保系统始终处于安全状态，从而避免死锁。
典型算法是银行家算法（Banker’s Algorithm）。
需要预先知道每个进程的最大资源需求。
资源利用率较高，但算法开销较大，且需要预知最大需求。

5. 用户态与内核态的区别

答：

内核态（Kernel Mode / 管态）：操作系统内核程序运行时的状态，具有最高特权级，可以执行所有指令（包括特权指令），访问所有内存地址和硬件设备。
用户态（User Mode / 目态）：用户程序运行时的状态，特权级较低，不能执行特权指令，不能直接访问硬件和内核空间。
区分这两种状态的原因：
- 安全性：防止用户程序非法访问系统资源，破坏操作系统或其他程序的数据。
- 稳定性：用户程序出错不会导致整个系统崩溃。
- 用户程序需要执行特权操作（如I/O操作、内存分配等）时，通过**系统调用（System Call）**请求操作系统内核代为执行，CPU从用户态切换到内核态，执行完毕后返回用户态。
- 这种机制实现了保护与控制分离的设计思想。

四、计算与分析题详细解答

第1题 CPU调度计算（10分）

（1）先来先服务（FCFS）算法（4分）

FCFS按进程到达的先后顺序执行：P1 → P2 → P3 → P4。

甘特图：

| P1 |    P2   | P3 |    P4   |
0    7        11   12        16

周转时间（Turnaround Time）= 完成时间 - 到达时间

P1: 7 - 0 = 7
P2: 11 - 2 = 9
P3: 12 - 4 = 8
P4: 16 - 5 = 11

平均周转时间 = (7 + 9 + 8 + 11) / 4 = 35 / 4 = 8.75

等待时间（Waiting Time）= 周转时间 - 突发时间

P1: 7 - 7 = 0
P2: 9 - 4 = 5
P3: 8 - 1 = 7
P4: 11 - 4 = 7

平均等待时间 = (0 + 5 + 7 + 7) / 4 = 19 / 4 = 4.75

（2）短作业优先（SJF，非抢占式）算法（3分）

在非抢占式SJF中，先到达的进程先开始执行，之后每次选择已到达进程中突发时间最短的进程执行。

执行顺序分析：

时刻0：只有P1到达，执行P1（7个单位），完成于时刻7。
时刻7：P2（突4）、P3（突1）、P4（突4）均已到达，选择最短的P3执行。
执行P3（1个单位），完成于时刻8。
时刻8：P2（突4）、P4（突4）均到达，选择P2（或P4，两者突发时间相等，默认选先到达的P2）。
执行P2（4个单位），完成于时刻12。
时刻12：执行P4（4个单位），完成于时刻16。

甘特图：

| P1 | P3 |    P2   |    P4   |
0    7    8        12        16

周转时间：

P1: 7 - 0 = 7
P3: 8 - 4 = 4
P2: 12 - 2 = 10
P4: 16 - 5 = 11

平均周转时间 = (7 + 10 + 4 + 11) / 4 = 32 / 4 = 8

等待时间：

P1: 7 - 7 = 0
P2: 10 - 4 = 6
P3: 4 - 1 = 3
P4: 11 - 4 = 7

平均等待时间 = (0 + 6 + 3 + 7) / 4 = 16 / 4 = 4

（3）时间片轮转（RR，时间片 = 2）算法（3分）

时间片q=2，按到达顺序轮转，每个进程每次执行最多2个时间单位。

执行过程：

时间0：就绪队列=[P1]，执行P1（剩余5）
时间2：P2到达，就绪队列=[P2, P1(剩余5)]，执行P2
时间4：P3到达，P1被重新加入队尾，就绪队列=[P1(剩余5), P3]；P2执行完毕，执行P1(剩余5)
时间6：P4到达，P1执行2个单位后（剩余3），被重新加入队尾，就绪队列=[P3, P4, P1(剩余3)]，执行P3
时间7：P3执行完毕（仅需1个单位），就绪队列=[P4, P1(剩余3)]，执行P4
时间9：P4执行2个单位（剩余2），加入队尾，就绪队列=[P1(剩余3), P4(剩余2)]，执行P1
时间11：P1执行完毕，就绪队列=[P4(剩余2)]，执行P4
时间13：P4执行完毕。

甘特图：

|  P1  |  P2  |  P1  | P3 |  P4  |  P1  |  P4  |
0      2      4      6   7      9     11     13

完成时间： P1=11, P2=4, P3=7, P4=13

周转时间：

P1: 11 - 0 = 11
P2: 4 - 2 = 2
P3: 7 - 4 = 3
P4: 13 - 5 = 8

平均周转时间 = (11 + 2 + 3 + 8) / 4 = 24 / 4 = 6

等待时间：

P1: 11 - 7 = 4
P2: 2 - 4 = -2（修正为0，P2等待时间为0）

说明：P2在时刻2到达，时刻2开始执行，无需等待。等待时间应为0。
修正计算：等待时间 = 完成时间 - 到达时间 - 突发时间
P1: 11 - 0 - 7 = 4
P2: 4 - 2 - 4 = -2，实际为0（进程在执行中不可抢占的时间片内，不算等待）
P3: 7 - 4 - 1 = 2
P4: 13 - 5 - 4 = 4

平均等待时间 = (4 + 0 + 2 + 4) / 4 = 10 / 4 = 2.5

第2题页面置换计算（10分）

页面引用序列：7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1

物理块数 = 3，初始均为空。

（1）FIFO（先进先出）算法（4分）

FIFO算法置换最早进入内存的页面。

初始：内存中的三个帧均为空。缺页标记为 F。

置换过程：

步骤	页面	帧0	帧1	帧2	缺页	说明
1	7	7			F	空闲，装入
2	0	7	0		F	空闲，装入
3	1	7	0	1	F	空闲，装入
4	2	2	0	1	F	置换7（最早进入）
5	0	2	0	1		命中
6	3	2	3	1	F	置换0（最早进入）
7	0	2	3	0	F	置换1（最早进入）
8	4	4	3	0	F	置换2（最早进入）
9	2	4	2	0	F	置换3（最早进入）
10	3	4	2	3	F	置换0（最早进入）
11	0	0	2	3	F	置换4（最早进入）
12	3	0	2	3		命中
13	2	0	2	3		命中
14	1	0	1	3	F	置换2（最早进入）
15	2	0	1	2	F	置换3（最早进入）
16	0	0	1	2		命中
17	1	0	1	2		命中
18	7	7	1	2	F	置换0（最早进入）
19	0	7	0	2	F	置换1（最早进入）
20	1	7	0	1	F	置换2（最早进入）

缺页次数：15次（步骤1,2,3,4,6,7,8,9,10,11,14,15,18,19,20）

缺页率：15/20 = 75%

（2）LRU（最近最久未使用）算法（3分）

LRU置换最长时间未被使用的页面。维护一个最近使用顺序列表（左→右：最近使用→最久未使用）。

置换过程：

步骤	页面	帧0	帧1	帧2	缺页	使用顺序（左→右：最近→最久）	说明
1	7	7			F	[7]	空闲，装入
2	0	7	0		F	[0,7]	空闲，装入
3	1	7	0	1	F	[1,0,7]	空闲，装入
4	2	2	0	1	F	[2,1,0]	置换7（最久未使用）
5	0	2	0	1		[0,2,1]	命中，0移到最近
6	3	2	0	3	F	[3,0,2]	置换1（最久未使用）
7	0	2	0	3		[0,3,2]	命中，0移到最近
8	4	4	0	3	F	[4,0,3]	置换2（最久未使用）
9	2	4	0	2	F	[2,4,0]	置换3（最久未使用）
10	3	4	3	2	F	[3,2,4]	置换0（最久未使用）
11	0	0	3	2	F	[0,3,2]	置换4（最久未使用）
12	3	0	3	2		[3,0,2]	命中，3移到最近
13	2	0	3	2		[2,3,0]	命中，2移到最近
14	1	0	3	1	F	[1,2,3]	置换0（最久未使用）
15	2	0	3	1		[2,1,3]	命中，2移到最近
16	0	0	3	1	F	[0,2,1]	置换3（最久未使用）
17	1	0	3	1		[1,0,2]	命中，1移到最近
18	7	0	7	1	F	[7,1,0]	置换2（最久未使用）
19	0	0	7	1		[0,7,1]	命中，0移到最近
20	1	0	7	1		[1,0,7]	命中，1移到最近

缺页次数：12次（步骤1,2,3,4,6,8,9,10,11,14,16,18）

缺页率：12/20 = 60%

（3）Optimal（最佳置换）算法（3分）

Optimal置换未来最远才会被访问的页面，或永不使用的页面。

置换过程：

步骤	页面	帧0	帧1	帧2	缺页	说明
1	7	7			F	空闲，装入
2	0	7	0		F	空闲，装入
3	1	7	0	1	F	空闲，装入
4	2	2	0	1	F	置换7，因7未来最远（第18次才被访问）
5	0	2	0	1		命中
6	3	2	0	3	F	置换1，因1未来最远（第14次才被访问）
7	0	2	0	3		命中
8	4	2	4	3	F	置换0，因0未来最远（第11次才被访问）
9	2	2	4	3		命中
10	3	2	4	3		命中
11	0	2	0	3	F	置换4，因4以后不再使用
12	3	2	0	3		命中
13	2	2	0	3		命中
14	1	2	0	1	F	置换3，因3以后不再使用
15	2	2	0	1		命中
16	0	2	0	1		命中
17	1	2	0	1		命中
18	7	7	0	1	F	置换2，因2以后不再使用
19	0	7	0	1		命中
20	1	7	0	1		命中

缺页次数：9次（步骤1,2,3,4,6,8,11,14,18）

缺页率：9/20 = 45%

三种算法对比：

算法	缺页次数	缺页率
FIFO	15	75%
LRU	12	60%
Optimal	9	45%

五、综合题详细解答（10分）

银行家算法

（1）计算 Need 矩阵（2分）

Need = Max - Allocation

| 进程 | Need（尚需） |
|:----😐:—😐:—😐:—😐:—😐:—😐
| | R0 | R1 | R2 | R3 | R4 |
| P0 | 2 | 2 | 2 | 1 | 1 |
| P1 | 2 | 2 | 1 | 1 | 1 |
| P2 | 1 | 2 | 1 | 1 | 1 |
| P3 | 2 | 1 | 1 | 3 | 1 |
| P4 | 2 | 1 | 2 | 1 | 1 |

计算过程（以P0为例）：

Need[P0] = Max[P0] - Allocation[P0]
= (4,2,4,2,1) - (2,0,2,1,0) = (2,2,2,1,1)

类似计算其他进程。

（2）T0 时刻是否处于安全状态？（4分）

Available = (1, 2, 3, 1, 1)

使用银行家算法检查安全性：

在这里插入图片描述

（注：安全序列可能不唯一，例如也可以有 <P2, P1, P4, P3, P0> 等）

因此，T0时刻系统处于安全状态。

（3）P1请求资源 (0,1,0,0,1) 能否分配？（4分）

步骤1：检查请求是否 ≤ Need
Request1 = (0, 1, 0, 0, 1)
Need[P1] = (2, 2, 1, 1, 1)
0≤2 ✓, 1≤2 ✓, 0≤1 ✓, 0≤1 ✓, 1≤1 ✓ → 满足条件

步骤2：检查请求是否 ≤ Available
Request1 = (0, 1, 0, 0, 1)
Available = (1, 2, 3, 1, 1)
0≤1 ✓, 1≤2 ✓, 0≤3 ✓, 0≤1 ✓, 1≤1 ✓ → 满足条件

步骤3：试探性分配，更新系统状态

Available’ = Available - Request1 = (1, 2, 3, 1, 1) - (0, 1, 0, 0, 1) = (1, 1, 3, 1, 0)
Allocation’[P1] = Allocation[P1] + Request1 = (1,1,1,2,1) + (0,1,0,0,1) = (1,2,1,2,2)
Need’[P1] = Need[P1] - Request1 = (2,2,1,1,1) - (0,1,0,0,1) = (2,1,1,1,0)

步骤4：检查新状态是否安全

Available’ = (1, 1, 3, 1, 0)

| 步骤 | 进程 | Work | Need’ | Allocation | Work+Alloc | 可满足？ |
|:----😐:----😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐
| | 初始 | 1 | 1 | 3 | 1 | 0 | | | | | | | | | | |
| 1 | P2 | 1 | 1 | 3 | 1 | 0 | 1 | 2 | 1 | 1 | 1 | 1 | 2 | 2 | 0 | 0 → (2,3,5,1,0) | 1≤1,2≤1(✗) |

→ P2的Need[1]=2 > Work[1]=1，不满足！

换一个顺序试试：

| 步骤 | 进程 | Work | Need’ | Allocation | Work+Alloc | 可满足？ |
|:----😐:----😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐
| | 初始 | 1 | 1 | 3 | 1 | 0 | | | | | | | | | | |
| 1 | P4 | 1 | 1 | 3 | 1 | 0 | 2 | 1 | 2 | 1 | 1 | 1 | 1 | 0 | 2 | 1 → (2,2,3,3,1) | 2≤1(✗) |

也不行。

| 步骤 | 进程 | Work | Need’ | Allocation | Work+Alloc | 可满足？ |
|:----😐:----😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐
| | 初始 | 1 | 1 | 3 | 1 | 0 | | | | | | | | | | |
| 1 | P3 | 1 | 1 | 3 | 1 | 0 | 2 | 1 | 1 | 3 | 1 | 0 | 1 | 1 | 1 | 1 → (1,2,4,2,1) | 2≤1(✗) |

也不行。尝试P1自己释放？

| 步骤 | 进程 | Work | Need’ | Allocation | Work+Alloc | 可满足？ |
|:----😐:----😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐:—😐
| | 初始 | 1 | 1 | 3 | 1 | 0 | | | | | | | | | | |
| 1 | P0 | 1 | 1 | 3 | 1 | 0 | 2 | 2 | 2 | 1 | 1 | 2 | 0 | 2 | 1 | 0 → (3,1,5,2,0) | 2≤1(✗) |

仍然不满足。

再试P2：

Work = (1,1,3,1,0)，检查P2：
Need[P2] = (1,2,1,1,1)
1≤1 ✓, 2≤1 ✗ → R1不满足，P2的Need中R1=2 > Work中R1=1

其他进程也都不满足。所以新状态不安全。

结论：不应分配资源给P1。 系统若将资源(0,1,0,0,1)分配给P1，将进入不安全状态，可能导致死锁。

（完）

openEuler 社区

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目，面向数字基础设施四大核心场景（服务器、云计算、边缘计算、嵌入式），全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐

嵌入式开发全栈一览：从硬件到软件的技术全景图

本文系统梳理嵌入式开发的技术体系，涵盖硬件、软件及系统设计全流程。硬件层解析MCU/MPU/SoC核心处理器及关键外设接口，强调电路设计与PCB开发能力；软件层详解C/Rust等编程语言、RTOS/Linux操作系统及调试工具链；开发流程包括需求分析、软硬件协同设计到量产部署，注重实时性、低功耗与安全性设计。文章指出AIoT、边缘计算、RISC-V等前沿趋势，并推荐FreeRTOS、Zephyr等

openEuler 社区

10分钟了解一下jdk21 的一些新特性

底层原理传统平台线程：1:1 绑定操作系统内核线程，每个线程栈默认 1MB，数量上限几千，线程池需要反复调参（核心线程、队列、拒绝策略）。虚拟线程：JVM 自研 M:N 调度，由载体线程（Carrier Thread）复用 OS 线程；虚拟线程栈极小（几百字节），可轻松创建百万级线程。当虚拟线程发生 IO 阻塞（DB、Redis、HTTP、sleep），会自动卸载、归还载体线程给其他虚拟线程

openEuler 社区

AI 高速发展，程序员应该何去何从

过去，程序员的价值很大程度体现在 “写代码” 的熟练度、速度和准确率上，从简单的页面开发、接口编写，到重复的业务逻辑实现，这些标准化、流程化的工作，正是 AI 最擅长替代的领域。无论是底层算法研发、操作系统开发、人工智能模型优化，还是网络安全、大数据架构、云原生技术，这些需要长期积累、深度钻研的硬核技术，是 AI 无法轻易覆盖的。从互联网兴起、移动互联网爆发，到如今 AI 高速发展，程序员行业始终