操作系统复习笔记(一)

1.整型信号量是一个整数变量,除初始化外,对其只能执行两个操作,即wait(s)和signal(s),也叫p(s)和v(s)操作,均是原语操作,用来实现进程的同步,互斥.
2.记录型信号量

type semaphore = record
value:integer
L: list of process;
end
procedure wait(s)
var s: semaphore;
begin
s.value = s.value - 1;
if(s.value<0) then block(s.L)
end
procedure signal(s)
var s: semaphore
begin
s.value = s.value +1;
if(s.value<=0) then wakeup(s.L)
end

结论:
(1) 若信号量s为正值,则等于在封锁进程之前对信号梁可以施行的p操作数,也就是s所代表的实际可以使用的物理资源数.
(2) 若信号量s为负值,则其绝对值等于排列在该信号量s队列之中等待的进程个数,也就等于对信号量s实施p操作而被封锁起来并进入信号量s队列的进程数.
(3)p操作一般代表请求一个资源，v操作一般代表着释放一个资源,在一定条件下，p操作代表挂起进程操作，v操作代表唤醒被挂起的进程.
3.经典同步问题
1)生产者/消费者问题
a) 问题一:有一个生产者和一个消费者,共享一个缓冲区.两者要互斥访问缓冲区.
解:定义两个信号量:empty表示缓冲是否为空，初值为1,即初始时可以存入一件物品.full表示缓冲区中是否有物品,初值为0,即初始时缓冲区没有物品.

程序:
begin
buffer:integer
empty,full:semaphore=1,0;
cobegin
process Producer
begin
L1:生产一件物品
wait(empty);
buffer = product;
signal(full);
goto L1;
end
process Consumer
begin
L2:wait(full);
从缓冲区取出一件物品;
signal(empty);
消费掉物品
goto L2;
end
coend
end

注:
(1)进程互斥只需要一个信号量,而同步可能要两个信号量.
(2)p,v操作仍然要成对,但在进程进入临界区前后调用的是针对不同信号量的wait,signal操作，而进程互斥时是针对相同的信号量.
(3)至少有一个信号量的初值>=1,否则所有进程无法执行,一般是指管理是否允许访问共享资源的那个信号量.如这里的empty设为1,如果缓冲区容量为n,则可以设为n;

b)问题二:m个生产者,n个消费者,容量为r的缓冲区,(m,n,r都大于1),不要生产者和消费者互斥存取物品.
解:1)生产者和消费者之间要同步,类似问题一,用两个信号量empty,full;2)m个生产者之间要互斥，n个消费者之间也要互斥,但生产者和消费者不用互斥存取物品,因此设两个计数器in,out和相应的互斥信号量mutex1,mutex2

程序:
begin
buffer:array[0 in,out:integer=0,0;
empty=r,full=0,mutex1=1,mutex2=1:semaphore;
cobegin
process Producer-i(i=1,2 begin
L1:生产一件物品;
wait(empty)
wait(mutex1)
buffer[in] = product;
in = (in+1)mod r;
signal(mutex1)
signal(full)
goto L1;
end
process Consumer-j(j=1,2 begin
L2: wait(full)
wait(mutex2)
take a product from buffer[out];
out =(out+1)mod r;
signal(mutex2)
signal(empty)
消费一件物品;
goto L2;
end

c)问题三:m个生产者,n个消费者,容量为r的缓冲区,(m,n,r都大于1),要求生产者和消费者互斥存取物品.
解:1)生产者和消费者之间要同步,类似问题一,用两个信号量empty,full;2)m个生产者之间要互斥，n个消费者之间也要互斥,同时要求生产者和消费者互斥存取物品,因此设两个计数器in,out和一个互斥信号量mutex.

代码:

begin
buffer:array[0 in,out:integer=0,0;
empty=r,full=0,mutex=1:semaphore;
cobegin
process Producer-i(i=1,2 begin
L1:生产一件物品;
wait(empty)
wait(mutex)
buffer[in] = product;
in = (in+1)mod r;
signal(mutex)
signal(full)
goto L1;
end
process Consumer-j(j=1,2 begin
L2: wait(full)
wait(mutex)
take a product from buffer[out];
out =(out+1)mod r;
signal(mutex)
signal(empty)
消费一件物品;
goto L2;
end

注:应该先执行对资源信号量的p,v操作,再执行互斥信号量的p,v操作，否则会引起死锁.

2)读者/写者问题
要求:(1)允许多个读者同时从数据区读数据;
(2)当读者在读数据时,不允许写者写数据
(3)任何时候只允许一个写者向数据区写数据;
(4)若有写者在写数据，则不允许读者读数据.
问题分为读者优先和写者优先两类。若有读者在读数据时,写者到来时就会被阻塞,直到所有读者读完数据才被唤醒.这里读者优先于写者,称为第一类读写问题.若读者在读数据时,有写者到来,则后续的读者将被阻塞,直到写者离开才被唤醒,这类问题中写者处于优势地位,叫第二类读写问题.

a)问题一:用记录型信号量解第一类读写问题

begin
var Rmutex,WRmutex:semaphore = 1,1;
readcount:integer=0;
cobegin

process Reader
begin
repeat
wait(Rmutex)
readcount = readcount+1;
if(readcount==1) wait(WRmutex);//第一个读者开始读数据，禁止写者访问
signal(Rmutex)
读数据
wait(Rmutex)
readcount = readcount-1;
if(readcount==0) signal(WRmutex);//没有读者读数据唤醒写者访问
signal(Rmutex)
until false
end

process Writer
begin
repeat
wait(WRmutex)
写数据
signal(WRmutex)
until false
end
coend
end
注:
(1)WRmutex用于读者和写者,写者和写者之间互斥访问数据区.
(2)当没有读者访问时,允许一个读者进入,第一个读者进入时要用WRmutex与写者互斥.
(3) readcount记录正在读数据区的读者数量,由于能被多个读者进程共享,也是临界资源，因此用Rmutex来对其实施互斥访问.
(4)允许多个读者同时读数据,当至少有一个读者在读时,其他读者不用等待就可以读数据。
(5)一旦有一个读者开始读数据，其后,只要至少还有一个读者在读数据，读者就一直保持对数据区的控制权,这会造成写者的"饥饿";

b)问题二:用AND信号量解第一类读写问题

begin
var L,mx:semaphore = RN,1;//最多只能有RN个读者同时读数据
cobegin

process Reader
begin
repeat
Swait(L,1,1);//L》1表示读者数量不满RN个，此读者可以读
Swait(mx,1,0);//mx》1表示没有写者在写数据，此读者可读
读数据
Ssignal(L,1);
until false
end

process Writer
begin
repeat
Swait(mx,1,1;L,RN,0);//mx》1表示没有写者在写数据，同时L》RN表示没有读者在读数据
写数据
Ssignal(mx,1);
until false
end
coend
end

c)第二类读写问题

begin
var Rmutex,WRmutex:semaphore,wx= 1,1,1;
readcount:integer=0;
cobegin

process Reader
begin
repeat
wait(wx)
wait(Rmutex)
readcount = readcount+1;
if(readcount==1) wait(WRmutex);//第一个读者开始读数据，禁止写者访问
signal(Rmutex)
读数据
wait(Rmutex)
signal(wx)
readcount = readcount-1;
if(readcount==0) signal(WRmutex);//没有读者读数据唤醒写者访问
signal(Rmutex)
until false
end

process Writer
begin
repeat
wait(wx)
wait(WRmutex)
写数据
signal(WRmutex)
signal(wx)
until false
end
coend
end
3)哲学家进餐问题

a)使用记录型信号量

begin
process Philosopher-i(i=1,2 begin
repeat
wait(chopstick[i])
wait(chopstick[(i+1)mod5])
吃饭
signal(chopstick[i])
signal(chopstick[(i+1)mod5])
思考
until false
end
end
b)使用AND信号量

begin
process Philosopher-i(i=1,25)
begin
repeat
思考
Swait(chopstick[i],chopstick[(i+1)mod5])
吃饭
Ssignal(chopstick[i],chopstick[(i+1)mod5])
until false
end
end

4.真题精选

[复旦2000]
问答: 在计算机科学文献中的几种互斥算法中，所谓的Lamport面包店算法可以有效地用于多个相互竞争的控制线程，该算法中线程之间的通信只能在共享内存中进行（即，不需要诸如信号量、原子性的set-and-test之类的专门机制）。该算法的基本思想源于面包店，因为面包店需要先取号然后等候叫号。下面给出了该算法的框架,该算法可以使各线程进出临界区而不产生冲突。

// declaration & initial values of global variables

// logic used by each thread// where "(a, b) < (c, d)"
// means "(a < c) or ((a == c) and (b < d))"

定义(a,b)<(c,d)为(a<c) or (a=c and b<d);
Enter[i]和Number[i]可以被进程i读写,但是只能被进程j(j<>i)读.
请问:(1)算法如何解决互斥访问临界区问题
(2) 算法如何解决死锁问题
分析:每个进入面包店的顾客会得到一个号码，服务员为拥有最小号码的顾客服务.此算法需要进程pi经过两个步骤进入临界区.第一步,它需要选择一个号码,因此,它读取其他进程的号码，并选择一个比它们的最大值大1的数字作为自己的号码(称为"面包店入口).第二步,进程pi用如下方法检查是否可以进入临界区.对任意其他进程pj,pi首先检查pj是否已经在面包店入口，如果在，那么pi等待pj离开面包店入口,然后pi等待Number[j]变为0或者Number[j],j) < (Number[i],i).当pi对所有其他进程成功验证上述条件后,就可以进入临界区.

解:
首先证明两个结论:
(1)若进程pi已经在临界区,而且若干其他进程pk已经选择了他们的号码，那么(Number[i],i) < (Number[k],k).
证明:若pi已经在临界区,则一定经历了k轮for循环,就是说在上述几轮循环中，Number[k]=0或者(Number[i],i) < (Number[k],k).首先假设进程pi读出Number[k]为0,也就是说pk还没有选择好一个号码,这里有两种情形:一是pk不在面包店入口,二是已经进入但还没有退出.若pk不在面包店入口,则它将可以读到最新的Number[i]的值,从而确保Number[k]>Number[i].若它已经在入口处,则此次进入一定是在pi检查了Enter[k]之后，因为pi在检查条件(Number[k]==0) && ((Number[i],i) < (Number[k],k))) 之前需要等待pk完成选择,也就是说pk将读到最新的Number[i]的值,因此确保Number[k]>Number[i].如果在k轮循环中,(Number[i],i) < (Number[k],k).那么这个结论将继续保持，因为Number[i]的值不会改变,而Number[k]只会增加.
(2)若进程pi在临界区中，则Number[i]>0
证明:因为此数值至少为0,当一个进程进入临界区之前一定执行了一个加1的操作.
由上述结论，若有两个进程pi和pk同时进入了临界区,由(2)知它们的号码都大于0,由(1),则有Number[k]>Number[i],反之也一样，所以矛盾.
对于死锁问题，由上述结论知,任一时刻一定存在一个进程pi,它的(Number[i],i)值最小，因此它总能够执行完成并归还资源,所以不会产生死锁.