操作系统复习笔记(一)

    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 r - 1 ]: integer
                 in , out :integer = 0 , 0 ;
                empty = r,full = 0 ,mutex1 = 1 ,mutex2 = 1 :semaphore;
                cobegin
                    process Producer - i(i = 1 , 2 m)
                    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 n)
                    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 r - 1 ]: integer
                 in , out :integer = 0 , 0 ;
                empty = r,full = 0 ,mutex = 1 :semaphore;
                cobegin
                    process Producer - i(i = 1 , 2 m)
                    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 n)
                    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
               var chopstick[ 5 ]:integer  =   {1,1,1,1,1} ;
                    process Philosopher - 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
            var chopstick[ 5 ]:integer  =   {1,1,1,1,1} ; 
                   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
Enter, Number: array [ 1 ..N] of integer  =   {0} ;

//  logic used by each thread
//  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) {
        // wait until thread j receives its number
      }
      while ((Number[j]!=0)
         && ((Number[j],j) < (Number[i],i))) {
        // wait until threads with smaller numbers
        // or with the same number, but with higher
        // priority, finish their work
      }
    }
    // critical section
    Number[i] = 0;
    // non-critical section
  }
}

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