操作系统复习笔记(一)

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

typesemaphore = record
value:integer
L:listofprocess;
end
procedurewait(s)
vars:semaphore;
begin
s.value = s.value - 1 ;
if (s.value < 0 )thenblock(s.L)
end
proceduresignal(s)
vars:semaphore
begin
s.value = s.value + 1 ;
if (s.value <= 0 )thenwakeup(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
processProducer
begin
L1:生产一件物品
wait(empty);
buffer = product;
signal(full);
goto L1;
end
processConsumer
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 r - 1 ]:integer
in , out :integer = 0 , 0 ;
empty = r,full = 0 ,mutex1 = 1 ,mutex2 = 1 :semaphore;
cobegin
processProducer - i(i = 1 , 2 m)
begin
L1:生产一件物品;
wait(empty)
wait(mutex1)
buffer[ in ] = product;
in = ( in + 1 )modr;
signal(mutex1)
signal(full)
goto L1;
end
processConsumer - j(j = 1 , 2 n)
begin
L2:wait(full)
wait(mutex2)
takeaproductfrombuffer[ out ];
out = ( out + 1 )modr;
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 r - 1 ]:integer
in , out :integer = 0 , 0 ;
empty = r,full = 0 ,mutex = 1 :semaphore;
cobegin
processProducer - i(i = 1 , 2 m)
begin
L1:生产一件物品;
wait(empty)
wait(mutex)
buffer[ in ] = product;
in = ( in + 1 )modr;
signal(mutex)
signal(full)
goto L1;
end
processConsumer - j(j = 1 , 2 n)
begin
L2:wait(full)
wait(mutex)
takeaproductfrombuffer[ out ];
out = ( out + 1 )modr;
signal(mutex)
signal(empty)
消费一件物品;
goto L2;
end

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

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

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

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

processReader
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

processWriter
begin
repeat
wait(WRmutex)
写数据
signal(WRmutex)
until false
end
coend
end

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

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

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

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

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

c)第二类读写问题

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

processReader
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

processWriter
begin
repeat
wait(wx)
wait(WRmutex)
写数据
signal(WRmutex)
signal(wx)
until false
end
coend
end

3)哲学家进餐问题

a)使用记录型信号量

begin
varchopstick[ 5 ]:integer = {1,1,1,1,1} ;
processPhilosopher - i(i = 1 , 2 5 )
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
varchopstick[ 5 ]:integer = {1,1,1,1,1} ;
processPhilosopher - 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&initialvaluesofglobalvariables
Enter,Number:array[ 1 ..N]ofinteger = {0} ;

// logicusedbyeachthread
// where"(a,b)<(c,d)"
// means"(a<c)or((a==c)and(b<d))"
Thread(i) {
while(true){
Enter[i]=1;
Number[i]=1+max(Number[1],,Number[N]);
Enter[i]=0;
for(j=1;j<=N;++j){
while(Enter[j]!=0){
//waituntilthreadjreceivesitsnumber
}
while((Number[j]!=0)
&&((Number[j],j)<(Number[i],i))){
//waituntilthreadswithsmallernumbers
//orwiththesamenumber,butwithhigher
//priority,finishtheirwork
}
}
//criticalsection
Number[i]=0;
//non-criticalsection
}
}

定义(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)值最小，因此它总能够执行完成并归还资源,所以不会产生死锁.