题目中没有文字的框应该是就绪队列。(1)系统采用的是时间片轮转法(或者剥夺调度)策略。(2)1是调度程序选择了一个进程可以占用CPU；2是时间片到时；3、4是发出I/O请求；5、6是I/O完成。

如图所示。
   
   (1)存在CPU空闲(在进程A运行后100～150ms，进程A正打印，进程B正输入)。CPU利用率为(300-50)÷300=83.3%。
   (2)进程A运行后无等待现象。
   (3)进程B运行后有等待现象(在A开始180～200ms；或进程B在运行后130～150ms)。

盘子为互斥资源，只能放入一个水果，设信号量empty初值为1；爸爸放苹果前先看看有无空间，若有则抢盘子，放入苹果后向女儿发信号；妈妈放橘子前先看看有无空间，若有则抢盘子，放入橘子后向儿子发信号；女儿先看有无苹果，若有则抢盘子，取走苹果后发出盘子置空的信号；儿子看有无橘子，若有则抢盘子，取走橘子后发出盘子置空的信号；置空信号应是爸爸和妈妈都可以接收的。该题是生产者/消费者问题的变形，有两对生产者和消费者。生产者需要指明是给哪个消费者的产品，但消费者取走产品后无须特别通知某个生产者，因为空出的缓冲区可由两个生产者随意争夺。此处无须设置信号量控制对盘子的互斥访问，因为盘子只能放一个产品；apple表示盘中有苹果，orange表示盘中有橘子，初值均为0。
   Parbegin
   爸爸:begin
   L1:p(empty);
   放苹果;
   V(apple);
   Goto L1;
   end;
   妈妈:begin
   L2:P(empty);
   放橘子;
   V(orange);
   Goto L2;
   end;
   女儿:begin
   L3:P(apple);
   取苹果;
   V(empty);
   Goto L3;
   end;
   儿子:begin
   L4:p(orange);
   取橘子;
   V(empty);
   Goto L4;
   end;
   Parend

对8位哲学家顺序编号为：P₁，P₂，P₃，P₄，P₅，P₆，P₇，P₈，对8个叉子顺序编号为：1，2，3，4，5，6，7，8。讨论每个哲学家的行为过程，再总结出规律，发现下标为奇数的哲学家是先拿左边的叉子，再拿右边的叉子；下标为偶数的哲学家先拿右边的叉子，再拿左边的叉子。由此得到以下程序，信号量S[i]的初值均为1。又因为编号P₈的哲学家拿起的是8号和1号叉子，因此用取余运算令其返回1。
   if(i%2==0) {
   P(S[i]);
   P(S[(i+1)%8]);
   吃;
   V(S[i]);
   V(S[(i+1)%8]);
   }
   else {
   P(S[i+1]);
   P(S[i]);
   吃;
   V(S[i+1]);
   V(S[i]);
   }
   该题不可能死锁。死锁产生的条件是所有的哲学家都从同一边拿起叉子，导致每个进程占用一个资源(叉子)而等待另一个资源，但该题的取叉子方式避免了这一现象。

遍历x是两个进程的共享资源，在进程同时申请访问时很容易出错。若采用顺序执行的方法，结构为y=1，z=1，t=2，u=2；若采用并发的方式，并按顺序①②③④⑤⑥⑦⑧执行，则结果为y=0，z=0，出错。改正的方法是为临界资源x设置信号量S，初值为1。程序如下：
   Parbegin
       Var x:integer;
       Process P1                    Process P2
       Vat y,z:integer;              Var t,u:integer;
       Begin                         Begin
           P(S);                         P(S);
           x:=1;                  ①     x:=0;                  ②
           y:=0;                  ③     t:=0;                  ⑥
           if x＞=1 then y:=y+1;  ④     if x＜=1 then t:=t+2;  ⑦
           V(S);                         V(S);
           z:=y;                  ⑤     u:=t;                  ⑧
       end                           end
   Parend

哥哥存两次钱后，amount=20，第三次存钱时，弟弟正在取钱，因没有对amount互斥操作，故发生错误。最后amount上可能出现的值应与两进程相对执行速度有关；若TAKE执行结束后SAVE才开始，则剩20元；若SAVE执行结束后TAKE才开始，也剩20元；问题就出在两个进程交替使用CPU时，则会出现不同值。关键在于最后被执行的语句是amount:=m1，还是amount:=m2，若先amount:=m1后amount:=m2，则amount=10，反之，先amount:=m2后amount:=m1，则amount=30。设信号量mutex(初值为1)控制两进程对变量amount的互斥使用。正确过程如下：
   begin
   amount:integer;
   amount:=0;
   cobegin
   Process SAVE
   m1:integer;
   Begin
   P(mutex);
   m1:=amount;
   m1:=m1+10;
   amount:=m1;
   V(mutex);
   end;
   Process TAKE
   m2:integer;
   Begin
   P(mutex);
   m2:=amount;
   m2:=m2-10;
   amount:=m2;
   V(mutex);
   end;
   coend;
   end;

思路如下：
   type semaphore=monitor;
   var acknowledgement1,acknowledgement2,acknowledgement3:boolean;
   x,y:condition;
   a,b,c:integer;
   指挥官:begin
   while acknowledgement1==false
   or acknowledgement2==false
   or acknowledgement3==false
   do x.wait;
   下达命令;
   a:=1;
   b:=1;
   c:=1;
   y.signal;
   end
   士兵1:begin
   while a==0 do y.wait;
   接收命令;
   acknowledgement1=true;
   x.signal;
   end
   士兵2:begin
   while a==0 do y.wait;
   接收命令;
   acknowledgement2:true;
   x.signal:
   end
   士兵3:begin
   while a==0 do y.wait;
   接收命令;
   acknowledgement3:true;
   X.signal;
   end
   begin
   a:=0;
   b:=0;
   c:=0;
   acknowledgement1:=false;
   acknowledgement2:=false;
   acknowledgement3:=false;
   end

读者有任意多个，但进入阅览室读最多为100人，为此可设一个信号量s，代表空座位的数目；另登记表为临界资源，需设一个用于互斥的信号量mutex，防止2个及2个以上的读者进程同时对此表访问。每个读者的动作包括进入、阅读、离开。
   struct semaphore:s,mutex=100,1;
   cobegin
   void readeri(void)(i=1,2,...,k) {
   while(TRUE) {
   P(s);
   P(mutex);
   查登记表,置某座位为占用;
   V(mutex);
   ...
   reading;
   ...
   P(mutex);
   查登记表,置某座位为空;
   V(mutex);
   V(s);
   }
   }
   coend

设置信号量：
   readcount:=0,nwriter:=0,swriter:=1,mutex:=1,wrt:=1;
   读者:P(swriter);
   if(nwriter==0) {
   P(mutex);
   readcount:=readcount +1;
   if(readcount==1)
   P(wrt);
   V(mutex);
   V(swriter);
   }
   else {
   V(swriter);
   block();
   }
   reading;
   P(mutex);
   readcount:=readcount-1;
   if(readcount==0)
   V(wrt);
   V(mutex);
   写者:P(swriter);
   nwriter:=nwriter+1;
   P(wrt);
   writing;
   P(swriter);
   nwriter:=nwriter-1;
   if(nwriter==0) {
   wakeup(读者进程);
   V(swriter); }
   else {
   V(wrt);
   V(swriter);
   }

首先在题目的初始条件上找安全序列。要想找安全序列，首先给出进程的剩余需求量，也就是在占有部分资源的基础上，还需要多少资源。列表如下：
   
   检查系统剩余资源数(1，4，0)，看是否可以一次性满足某个进程的全部剩余需求量。找到P₀和P₂，则选其一进入安全序列，并假设该进程已完成，然后将进入安全序列的进程所占有的资源回收，再检查是否可以一次性满足某个进程的全部剩余需求量。依次类推，最后如果所有进程都可以进入安全序列，则系统处于安全状态，不会死锁。本题第一问的答案是：当前系统处于安全状态，因为至少可以找到一个安全序列＜P₀，P₂，P₁，P₃，P₄＞(答案不定)。
   如果系统中可用资源为(0，6，2)，则只可满足P₃的要求，P₃归还后，可满足P₄的要求，P₄归还后，可满足P₀的要求，P₀归还后，无法满足P₁和P₂的要求，即找不到安全序列，因此系统处在不安全状态。

会死锁。因为对两个账户进行加锁操作是可以分割进行的，若此时有两个用户同时进行转账，P₁先对账户A进行加锁，再申请账户B；P₂先对账户B进行加锁，再申请账户A，此时死锁。解决办法是：可以采用资源顺序分配法将A、B账户进行编号，用户转账时只能按照编号由小到大进行加锁；也可以采用资源预分配法，要求用户在使用资源之前将所有资源一次性申请到。

不发生死锁必须保证至少有1个进程可以得到所需的全部资源并执行完毕，若m≥n(k-1)+1则一定不会发生死锁(见下表)。

序号	m	n	k	是否会死锁
1	6	3	3	可能会
2	9	3	3	不会
3	13	6	3	不会

这个问题实际上可看作是两个生产者和两个消费者共享了一个仅能存放一件产品的缓冲器。生产者各自生产不同的产品，消费者各自取自己需要的产品。利用P，V操作编程为：
   begin
   semaphore:S,S1,S2;
   Parbegin
   Process hunter
   begin
   L1:have a tiger;
   P(S);
   put a tiger;
   V(S1);
   go to L1;
   end;
   Process peasant
   begin
   L2:have a pig;
   P(S);
   put a pig;
   V(S2);
   go to L2;
   end;
   Process hotel
   begin
   L3:P(S1);
   get a pig;
   V(S);
   eat a pig;
   go to L3;
   end;
   Process zoo
   begin
   L4:P(S2);
   get a tiger;
   V(S);
   eat a tiger;
   goto L4;
   end;
   parend

在本题中，进程PA，PB，PC之间的关系为：PA与PB共用一个单缓冲区，而PB又与PC共用一个单缓冲区。当缓冲区1为空时，进程PA可将一个记录读入其中；若缓冲区1中有数据且缓冲区2为空，则进程PB可将记录从缓冲区1复制到缓冲区2中；若缓冲区2中有数据，则进程PC可以打印记录。在其他条件下，相应进程必须等待。事实上，这是一个生产者—消费者问题。
   为遵循这一同步规则，应设置四个信号量empty1，empty2，full1，full2，信号量empty1及empty2分别表示缓冲区1及缓冲区2是否为空，其初值为1；信号量full1及full2分别表示缓冲区1及缓冲区2是否有记录可供处理，其初值为0。其同步描述如下：
   int empty1=1;
   int empty2=1;
   int full1=0;
   int full2=0;
   main() {
   cobegin
   PA();
   PB();
   PC();
   coend
   }
   PA() {
   while(1) {
   从磁盘读一个记录:
   P(empty1);
   将记录存入缓冲1;
   V(full1);
   }
   }
   PB() {
   while(1) {
   从缓冲区1中取出记录:
   V(empty1);
   P(empty1);
   将记录存入缓冲2;
   V(full2);
   }
   }
   PC() {
   while(1) {
   P(full2);
   从缓冲区2中取出记录;
   V(empty2);
   打印记录;
   }
   }
   本题也是一个典型的生产者一消费者问题。其中的难点在于PB既是一个生产者又是一个消费者。

在本题中，允许读进程同时读数据库，但写进程正在写数据库时不允许其他进程读数据库，也不允许其他进程写该数据库。为了解决读、写进程之间的同步，应设置两个信号量和一个共享变量：读互斥信号量rmutex，用于使读进程互斥地访问共享变量count，其初值为1；写互斥信号量wmutex用于实现写进程与读进程的互斥及写进程与写进程的互斥，其初值为1；共享变量count用于记录当前正在读数据库的读进程数目，初值为0。其工作过程如下：
   int rmutex=1;
   int wmutex=1;
   int count=0;
   main() {
   cobegin
   Reader();
   Writer();
   coend
   }
   Reader() {
   while(1) {
   P(rmutex):
   if(count==0)
   P(wmutex);//当第一个读进程读数据库时,阻止写进程写;
   count++;
   V(rmutex):
   读数据库;
   P(rmutex);
   count--;
   if(count==0)
   V(wmutex);//当最后一个读进程读完数据库时,允许写进程写;
   V(rmutex);
   }
   Writer() {
   while(i) {
   P(wmutex);
   写数据库;
   V(wmutex);
   }
   }
   在本题中，要注意对信号量rmutex意义的理解。rmutex是一个互斥信号量，用于使读进程互斥地访问共享变量count。该信号量并不表示读进程的数目，表示读进程数目的是共享变量count。当一个读进程要读数据库时，应将读进程计数count增加1。如果此前(count加1以前)数据库中无读进程，还应对写互斥信号量wmutex做P操作，这样若数据库中无写进程，则通过P操作组织写进程写；若数据库中有写进程，则通过P操作让读进程等待。
   同理，当一个读进程完成读数据库操作时，应将读进程计数count减少1；如果此时(count减1以后)数据库中已无读进程，还应对写互斥信号wmutex作V操作，以允许写进程写。

semaphore smoker[3];//初始0,三个抽烟者
   semaphore material[3];//初始0,三种原料
   semaphore agent;//初始1,供应商
   int turn;//初始0,轮到谁
   agent:
   while(1) {
   wait(agent);
   signal(smoker[turn]);
   signal(material[(turn+1)%3]);
   signal(material[(turn+2)%3]);
   turn=(turn+1)%3
   }
   smoker—i:
   while(1) {
   wait(smoker[i]);
   wait(material[(i+1)%3]);
   Wait(material[(i+2)%3]);
   signal(agent);
   }

三个作业并发执行时的工作情况如下：
   Job₁的执行顺序为：I₂(30ms)；CPU(10ms)；I₁(30ms)；CPU(10ms)；等待I₂(10ms)；I₂(20ms)。
   Job₂的执行顺序为：I₁(20ms)；CPU(10ms)；等待CPU(10ms)；CPU(10ms)；I₂(40ms)；
   Job₃的执行顺序为：CPU(20ms)；等待CPU(30ms)；CPU(10ms)；等待I₁(10ms)；I₁(20ms)；CPU(10ms)；I₁(10ms)。
   (1)Job₁从投入到运行完成需要110ms，Job₂从投入到运行完成需要90ms，Job₃从投入到运行完成需要110ms。
   (2)CPU在时间段60～70ms，80～90ms，100～110ms期间空闲，所以CPU的利用率为：(110-30)/110=72.7%。
   (3)设备I₁在时间段20～40ms，90～100ms期间空闲，所以设备I₁的利用率为：(110-30)/110=72.7%；
   设备I₂在时间段30～50ms期间空闲，所以设备I₂的利用率为：(110-20)/110=81.8%。