- 利用信号量机制,根据前驱图定义信号量写出可以并发执行的程序实现前驱关系.
首先,我们先需要设置一些信号量a,b,c,…,h来保证s1->s2,s1->s3等等这些前驱和后继的关系;其次,就是需要明白singal(信号量名称)表示释放某种信号量,wait(信号量名称)表示申请一种资源;OK那么就来看看具体如何书写:
p1(){S1;signal(a);singal(b);}
p2(){wait(a);S2;singal(c);}
p3(){wait(b);S3;singal(d);singal(e);}
p4(){wait(c);S4;singal(f);}
p5(){wait(d);S5;singal(g);}
p6(){wait(e);S6;singal(h);}
p7(){wait(f);wait(g);wait(h);S7;}
main(){
samephore a,b,c,d,e,f,g,h;
a.value = b.value = c.value = d.value = e.value = f.value = g.value = h.value = 0;
cobegin
p1();p2();p3();p4();p5();p6();p7();
coend
}
}
只需要记住具体框架,然后往里面套就可以啦~
| 已分配资源数 | | | 资源请求量 | |
---|
| R1 | R2 | | R1 | R2 |
P1 | 2 | 0 | | 0 | 1 |
P2 | 1 | 1 | | 1 | 1 |
(1)画出资源分配图:

(2)化简资源分配图,判断是否会发生死锁:
首先看进程P1,P1只申请一个R2资源,系统可以满足它,那么我们就可以将P1化简为一个孤立的进程;
其次再看P2,由于当前R1资源已经分配完,无法满足,我们就只能保留P2进程的所有关系;
当进程P1执行完毕释放资源后,我们发现此时系统可以满足P2进程的需求,也就是说,当前P2进程也可以简化为一个孤立的进程,因此不会发生死锁!

- 银行家算法,找出安全序列以及判断是否可以申请资源成功
资源分配情况如下:
| Allocation | Allocation | Allocation | | Max | Max | Max |
---|
| R1 | R2 | R3 | | R1 | R2 | R3 |
P0 | 3 | 2 | 1 | | 4 | 3 | 7 |
P1 | 2 | 3 | 1 | | 3 | 4 | 4 |
P2 | 1 | 4 | 3 | | 5 | 6 | 3 |
P3 | 4 | 2 | 2 | | 7 | 3 | 4 |
P4 | 3 | 2 | 1 | | 6 | 4 | 3 |
(1)求出此时的可用资源数和资源需求量
可用资源数 = 资源总数-已分配的资源
R1的可用资源数 = 14-(3+2+1+4+3)=1
R2的可用资源数 = 15-(2+3+4+2+2)=2
R3的可用资源数 = 12-(1+1+3+2+1) = 4
可用资源数如下表:
资源需求量 = 最大需求量Max-Allocation(已分配资源)
这里大家就自己计算一下,我就把表格列出来
| R1 | R2 | R3 |
---|
P0 | 1 | 1 | 6 |
P1 | 1 | 1 | 3 |
P2 | 4 | 2 | 0 |
P3 | 3 | 1 | 2 |
P4 | 3 | 2 | 2 |
(2)是否存在安全序列?
根据银行家算法,我们需要将第(1)问所求得的可用资源数作为最开始的work向量,然后在P0-P4五个进程中找到need小于work向量的进程,把它的work和allocation找到,填入表中计算出work+allocation作为下一次的work向量,如果P0-P4五个向量均能满足,那么就找到安全序列了
进程 | Work | Work | Work | | Need | Need | Need | | Allocation | Allocation | Allocation | | work+Allocation | work+Allocation | work+Allocation | | finish |
---|
P1 | 1 | 2 | 4 | | 1 | 1 | 3 | | 2 | 3 | 1 | | 3 | 5 | 5 | | true |
P3 | 3 | 5 | 5 | | 3 | 1 | 2 | | 4 | 2 | 2 | | 7 | 7 | 7 | | true |
P0 | 7 | 7 | 7 | | 1 | 1 | 6 | | 3 | 2 | 1 | | 10 | 9 | 8 | | true |
P2 | 10 | 9 | 8 | | 4 | 2 | 0 | | 1 | 4 | 3 | | 11 | 13 | 11 | | true |
P4 | 11 | 13 | 11 | | 3 | 2 | 2 | | 3 | 2 | 1 | | 14 | 15 | 12 | | true |
因此存在安全序列,安全序列为{P1,P3,P0,P2,P4}
(2)若P4请求(1,2,0),那么系统可以把资源分配给它吗?
第一步,观察request(1,2,0)是否小于P4的need(3,2,2),我们发现是满足的;
第二步,观察request(1,2,0)是否小于Available(可用资源数),我们发现它是小于(1,2,4)的;
第三步,我们试探性分配,此时假设P4请求成功,那么新的Available为(0,0,4),如果继续分配不能满足任何进程的需求,不满足银行家算法,因此系统不能将资源分配给P4
- 磁盘调度算法相关习题
若干个等待访问磁盘一次要访问的磁道号为20,44,40,4,80,12,76,假设每次移动一个磁道需要3毫秒,移动臂当前位于40号柱面,依次求出下列算法的寻道总时间:
(1)先来先服务(FCFS)算法:
解题思路:首先画个表格按顺序将磁道号列出来,前一个磁道号减去当前磁道号的绝对值就是移动距离,将所有的移动距离加起来×3就是总时间;
下一个被访问的磁道号 | 20 | 44 | 40 | 4 | 80 | 12 | 76 |
---|
移动距离 | 20 | 24 | 4 | 36 | 76 | 68 | 64 |
寻道总时间 =(20+24+4+36+76+68+64)×3=876(毫秒)
(2)最短寻道时间(SSTF)算法:
解题思路:首次寻找距离移动臂最近的磁道号,依次找到距离前一个磁道号最近的磁道,求差值的绝对值就是移动距离,将所有的移动距离加起来×3就是总时间;
下一个被访问的磁道号 | 40 | 44 | 20 | 12 | 4 | 76 | 80 |
---|
移动距离 | 0 | 4 | 24 | 8 | 8 | 72 | 4 |
寻道总时间 =(0+4+24+8+8+72+4)×3=360(毫秒)
(3)扫描(Scan)算法
解题思路:先按照升序寻找距离移动臂最近的磁道号,依次按顺序遍历求差值,大于移动臂的找完了之后开始便利磁道号小于移动臂的,计算总时间的方法同上;
下一个被访问的磁道号 | 40 | 44 | 76 | 80 | 20 | 12 | 4 |
---|
移动距离 | 0 | 4 | 32 | 4 | 60 | 8 | 8 |
寻道总时间 =(0+4+32+4+60+8+8)×3=348(毫秒)
- 页面置换算法相关题目
某请求分页的存储管理系统,且页面大小为120字节。考虑一仅580个字节的程序的下述内存访问序列(该序列的下标均从0开始):080,119,384,270,173,199,025,245,186,334,458,355。
(1)写出页面的访问序列。
(2)假设内存中仅有360字节可供程序使用且采用FIFO算法,那么共发生多少次缺页中断?
(3)假设内存中仅有360字节可供程序使用且采用LRU算法,则又会发生多少次缺页中断?
(4)假设内存中仅有360字节可供程序使用且采用OPT算法,则又会发生多少次缺页中断?
(1)求页面访问序列也就是让你求出对应的页号 -> 页号 = [对应的访问序列/页面大小]注意:[x]表示对x向下取整
比如说080对应的页号就是80/120向下取整,得到页号=0
按照相同的方法,我们就可以得到页面访问序列:
0,0,3,2,1,1,0,2,1,2,3,2
(2)先读题确定一下物理块有几块;
物理块个数 = 内存中仅有字节÷每页字节数=360÷120=3
下面表格中出现的页号就是访问序列
接下来列表格:
页号 | 0 | 0 | 3 | 2 | 1 | 1 | 0 | 2 | 1 | 2 | 3 | 2 |
---|
物理块1 | 0 | 0 | 3 | 2 | 2 | 1 | 1 | 0 | 0 | 0 | 0 | 3 |
物理块2 | - | - | 0 | 3 | 3 | 2 | 2 | 1 | 1 | 1 | 1 | 0 |
物理块3 | - | - | - | 0 | 0 | 3 | 3 | 2 | 2 | 2 | 2 | 1 |
缺页 | √ | - | √ | √ | - | √ | - | √ | - | - | - | √ |
根据表格得出缺页7次;
(3)
当物理块被填满时候,就看从当前页面序号往右看将最近没有使用的那一个页号淘汰
页号 | 0 | 0 | 3 | 2 | 1 | 1 | 0 | 2 | 1 | 2 | 3 | 2 |
---|
物理块1 | 0 | 0 | 3 | 2 | 1 | 1 | 0 | 2 | 1 | 2 | 3 | 2 |
物理块2 | - | - | 0 | 3 | 2 | 2 | 1 | 0 | 2 | 1 | 2 | 3 |
物理块3 | - | - | - | 0 | 3 | 3 | 2 | 1 | 0 | 0 | 1 | 1 |
缺页 | √ | - | √ | √ | √ | - | √ | - | - | - | √ | - |
缺页中断6次
(4)
当物理块被填满时候,就看从当前页面序号往左看将最近不会使用的那一个页号淘汰
页号 | 0 | 0 | 3 | 2 | 1 | 1 | 0 | 2 | 1 | 2 | 3 | 2 |
---|
物理块1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 3 | 3 |
物理块2 | - | - | 3 | 3 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
物理块3 | - | - | - | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
缺页 | √ | - | √ | √ | √ | - | - | - | - | - | √ | - |
缺页中断5次
- 求物理地址
先看一个简单的:
在采用页式存储管理的系统中,某进程的逻辑地址空间为4页(每页2048字节),已知该进程的页面映像表(页表)如下:
计算有效逻辑地址4865所对应的物理地址;
解:地址转换公式,这个一定一定要牢记:
物理地址 = 块号×块长+块内地址(页内偏移量)
页号 = 有效地址%每页字节数
解题步骤:①求页号②对照页表找块号③根据公式计算地址
页号 = 4865 % 2048 = 2…769
根据页号找到块号为6
所以物理地址 = 6×2048+769 = 13057
提升难度:
例1:一个进程的页面大小占5个页面,每页大小为1k,系统给它分配了3个物理块,当前进程的页表如下:
页号 | 块号 | 存在位P | 访问位R | 修改位M |
---|
0H | 1CH | 1 | 1 | 0 |
1H | 3FH | 1 | 1 | 1 |
2H | - | 0 | 0 | 0 |
3H | 5DH | 1 | 0 | 0 |
4H | - | 0 | 0 | 0 |
(1)哪些页面不在内存?
不在内存的页面的块号为0,所以第2页,第4页不在内存
(2)分别计算进程逻辑地址为3B7H、12A5H、1432H单元的物理地址(用16进制表示),并说明理由.
解:
(3B7)16进制转换为2进制可以表示为 0011 1011 0111
因为页面大小为1K=2^10,所以页内地址就是逻辑地址的低10位:11 1011 0111;
则页号为0,对应的块号为1CH
1C用2进制可以表示为:0001 1100
那么物理地址就可以用块号对应的2进制拼接上页内地址,也就是:
(0001 1100 11 1011 0111),转化为16进制就是(73B7)
理由:访问内存中的页表,是从表中找到对应的物理块号,再将块号与页内偏移量拼接,形成了物理地址(重要!!!)
(12A5)转化为2进制可以表示为 0001 0010 1010 0101
因为页面大小为1K=2^10,所以页内地址就是逻辑地址的低10位:10 1010 0101
则页号为4H,缺页,需要置换
置换规则需要参考访问位R和修改位M的取值;置换出来的页面优先级依次是R,M的组合为(0,0)->(0,1)->(1,0)->(1,1)
根据置换规则,将3H置换出来
5D对应的2进制为:0101 1101
那么物理地址就可以用块号对应的2进制拼接上页内地址,也就是:
(0101 1101 10 1010 0101),转化为16进制就是(176A5)
(1432)用2进制可以表示为:0001 0100 0011 0010
因为页面大小为1K=2^10,所以页内地址就是逻辑地址的低10位:00 0011 0010
页号为5H,越界出错,没有对应的物理地址
例2:
设一分页系统,某作业的逻辑地址空间为4页(每页2048字节),已知该作业的页表如下:
(1)试着借助地址变换图,求逻辑地址为3658所对应的物理地址;

(2)访问逻辑地址3658对应的单元内容,需要访问几次内存,为什么?
答:需要访问2次内存;第一次是根据页表找到对应的物理块号,再将块号与页内偏移量拼接,从而形成物理地址;第二次访问内存时,才是从第一次得到的地址中获取数据;
- 时间片轮转算法
在一个多道作业的操作系统中,设在一段时间内先后到达4个作业,它们的提交时刻和运行时间由下表给出。进程调度采用时间片轮转调度算法,时间片大小为2。
完成下表格;
进程名 | 到达时间 | 估计运行时间 | 开始时间 | 完成时间 | 周转时间 | 带权周转时间 |
---|
A | 0 | 5 | | | | |
B | 1 | 3 | | | | |
C | 3 | 5 | | | | |
D | 4 | 2 | | | | |
首先根据表格中给出的A,B,C,D进程的到达时间和估计运行时间写访问序列:
根据上面的就可以得到开始时间和完成时间;
周转时间 = 完成时间-到达时间
带权周转时间 = 周转时间÷服务时间
进程名 | 到达时间 | 估计运行时间 | 开始时间 | 完成时间 | 周转时间 | 带权周转时间 |
---|
A | 0 | 5 | 0 | 12 | 12 | 2.40 |
B | 1 | 3 | 2 | 11 | 10 | 3.33 |
C | 3 | 5 | 6 | 15 | 12 | 2.40 |
D | 4 | 2 | 8 | 10 | 6 | 3.00 |
- 信号量机制p,v操作
有一只铁笼子,每次只能放入一只动物,猎手向笼子里放入老虎,农民向笼子里放入猪;动物园等待取笼子里的老虎,饭店等待取笼子里的猪。现请用wait和signal操作写出能同步执行的程序。请回答下列问题:
(1).用P、V操作管理这些并发进程时,应定义哪几个信号量,每个信号量的含义是什么;并给出每个信号量的初值。
首先我们读题找出资源信号量和互斥信号量
应该定义3个信号量:
semaphore mutex,pig,tiger;
mutex = 1; 表示当前笼子里面没有动物;
pig = 0;表示当前猪的数量;
tiger = 0;表示当前老路的数量
(2).根据所定义的信号量,把应执行的P、V操作填入下述空格中,以保证进程能够正确地并发执行。
begin
parbegin
Hunter: begin
repeat
① wait(tiger) ;
;
② wait(mutex) ;
until false;
end;
Farmer: begin
repeat
③***singal(mutex)*** ;
;
④ single(tiger) ;
until false;
end;
Zoo: begin
repeat
⑤ wait(pig) ;
;
⑥ wait(mutex) ;
until false;
end;
Hotel: begin
repeat
⑦ singal(mutex) ;
;
⑧ single(pig) ;
until false;
end;
parend;
end;
计算大题就暂时更新到这里,下一篇说一下简答题~