15 试说明引起进程阻塞或被唤醒的主要事件是什么? a. 请求系统服务； b. 启动某种操作； c. 新数据尚未到达； d. 无新工作可做.
16 试从调度性，并发性，拥有资源及系统开销几个方面，对进程和线程进行比较.
a. 在引入线程的 OS 中，把线程作为调度和分派的基本单位，而把进程作为资源拥有的基本单位； b. 在引入线程的 OS 中，不仅进程之间可以并发执行，而且在一个进程中的多个线程之间，亦可并发执行， 因而使 OS 具有更好的并发性；
c. 进程始终是拥有资源的一个独立单位，线程自己不拥有系统资源，但它可以访问其隶属进程的资源； d. 在创建，撤消和切换进程方面，进程的开销远远大于线程的开销. 17 什么是用户级线程和内核级线程?并对它们进行比较.
a. 内核级线程是依赖于内核的，它存在于用户进程和系统进程中，它们的创建，撤消和切换都由内核实 现；
---用户级线程仅存在于用户级中，它们的创建，撤消和切换不利用系统调用来实现，因而与内核无关， 内核并不知道用户级线程的存在.
b. 内核级线程的调度和切换与进程十分相似，调度方式采用抢占式和非抢占式，调度算法采用时间轮转 法和优先权算法等，当由线程调度选中一个线程后，再将处理器分配给它；而用户级线程通常发生在一个 应用程序的诸线程之间，无需终端进入 OS 内核，切换规则也较简单，因而，用户级线程的切换速度较快.
---用户级线程调用系统调用和调度另一个进程执行时，内核把它们看作是整个进程的行为，内核级线程 调用是以线程为单位，内核把系统调用看作是该线程的行为.
---对于用户级线程调用，进程的执行速度随着所含线程数目的增加而降低，对于内核级线程则相反. 18 在 Solaris OS 中，设置了哪几种线程?轻型线程的作用是什么? a. 用户级线程，内核级线程和轻型线程；
b. 作用: 由 LWP 实现了在内核与用户级线程之间的隔离，从而使用户级线程与内核无关. 19 在 Solaris OS 中，用户级线程是通过什么方式来访问内核的?
通过 LWP 来访问内核. LWP 可为内核所识别，但不能识别用户级线程，通过建立用户级线程与 LWP 之间的 连接，可以实现用户级线程与内核的通信.
第三章
1. 什么是临界资源和临界区?
a. 一次仅允许一个进程使用的资源成为临界资源.
b. 在每个进程中，访问临界资源的那段程序称为临界区.
2. 为什么进程在进入临界区之前，应先执行\进入区\代码，在退出临界区后又执行\退出区\代码? 为了实现多个进程对临界资源的互斥访问，必须在临界区前面增加一段用于检查欲访问的临界资源是否正 被访问的代码，如果未被访问，该进程便可进入临界区对资源进行访问，并设置正被访问标志，如果正被 访问，则本进程不能进入临界区，实现这一功能的代码成为\进入区\代码；在退出临界区后，必须执行\退出区\代码，用于恢复未被访问标志.
3. 同步机构应遵循哪些基本准则?为什么? a. 空闲让进. b. 忙则等待. c. 有限等待. d. 让权等待.
4. 试从物理概念上来说明记录型信号量和 wait 和 signal 操作?(有待讨论). 5. 你认为整型信号量机制和记录型信号量机制，是否完全遵循了同步机构的四条准则? a. 在整型信号量机制中，未遵循\让权等待\的准则.
b. 记录型信号量机制完全遵循了同步机构的\空闲让进,忙则等待,有限等待,让权等待\四条准则. 6. 在生产者－消费者问题中，如果缺少了 signal(full)或 signal(empty),对执行结果会有何影响? 生产者－消费者问题可描述如下:
var mutex,empty,full: semaphore:=1,n,0; buffer: array[0,...,n-1] of item; in,out: integer:=0,0; begin parbegin
producer: begin repeat . .
produce an item in nextp; . . wait(empty); wait(mutex);
buffer(in):=nextp; in:=(in+1) mod n; signal(mutex);
/* ************** */ signal(full);
/* ************** */ until false; end
consumer: begin repeat wait(full); wait(mutex);
nextc:=buffer(out); out:=(out+1) mod n; signal(mutex);
/* ************** */ signal(empty);
/* ************** */
consume the item in nextc; until false; end parend end
可见，生产者可以不断地往缓冲池送消息，如果缓冲池满，就会覆盖原有数据，造成数据混乱.而消费者 始终因 wait(full)操作将消费进程直接送入进程链表进行等待，无法访问缓冲池,造成无限等待.
7. 在生产者－消费者问题中，如果将两个 wait 操作即 wait(full)和 wait(mutex)互换位置；或者是将
signal(mutex)与 signal(full)互换位置结果会如何? var mutex,empty,full: semaphore:=1,n,0; buffer: array[0,...,n-1] of item; in,out: integer:=0,0; begin parbegin
producer: begin repeat . .
produce an item in nextp; . . wait(empty); wait(mutex);
buffer(in):=nextp; in:=(in+1) mod n; /* ***************** */ signal(full); signal(mutex);
/* ***************** */ until false; end
consumer: begin repeat
/* **************** */ wait(mutex); wait(full);
/* **************** */ nextc:=buffer(out); out:=(out+1) mod n; signal(mutex); signal(empty);
consume the item in nextc; until false; end parend
end
a. wait(full)和 wait(mutex)互换位置后，因为 mutex 在这儿是全局变量，执行完 wait(mutex)，则 mutex 赋值为 0，倘若 full 也为 0，则该生产者进程就会转入进程链表进行等待，而生产者进程会因全局变量 mutex 为 0 而进行等待，使 full 始终为 0，这样就形成了死锁.
b. 而 signal(mutex)与 signal(full)互换位置后，从逻辑上来说应该是一样的.
8. 我们为某临界区设置一把锁 W，当 W=1 时，表示关锁；W=0 时，表示锁已打开.试写出开锁原语和关锁 原语，并利用它们去实现互斥. 开锁原语: unlock(W): W=0; 关锁原语: lock(W);
if(W==1) do no_op; W=1;
利用开关锁原语实现互斥: var W: semaphore:=0; begin parbegin process : begin repeat lock(W);
critical section unlock(W); remainder section until false; end parend
9. 试修改下面生产者－消费者问题解法中的错误: producer: begin repeat . .
producer an item in nextp; wait(mutex);
wait(full); /* 应为 wait(empty),而且还应该在 wait(mutex)的前面 */ buffer(in):=nextp;
/* 缓冲池数组游标应前移: in:=(in+1) mod n; */ signal(mutex);
/* signal(full); */ until false; end consumer:
begin repeat wait(mutex);
wait(empty); /* 应为 wait(full),而且还应该在 wait(mutex)的前面 */ nextc:=buffer(out);
out:=out+1; /* 考虑循环，应改为: out:=(out+1) mod n; */ signal(mutex);
/* signal(empty); */ consumer item in nextc; until false; end
10 试利用记录型信号量写出一个不会出现死锁的哲学家进餐问题的算法.
设初始值为 1 的信号量 c[I]表示 I 号筷子被拿(I=1,2,3,4,...,2n),其中 n 为自然数. send(I): Begin
if I mod 2==1 then { P(c[I]);
P(c[I-1 mod 5]); Eat;
V(c[I-1 mod 5]); V(c[I]); } else {
P(c[I-1 mod 5]); P(c[I]); Eat; V(c[I]);
V(c[I-1 mod 5]); } End
11 在测量控制系统中的数据采集任务，把所采集的数据送一单缓冲区；计算任务从该单缓冲中取出数据 进行计算.试写出利用信号量机制实现两者共享单缓冲的同步算法. int mutex=1; int empty=n; int full=0; int in=0; int out=0; main() { cobegin send(); obtain();