信号量和PV操作

FROM: http://docs.huihoo.com/os/process/semaphore.htm

信号量是最早出现的用来解决进程同步与互斥问题的机制，包括一个称为信号量的变量及对它进行的PV原语操作。

一. 信号量的概念

1． 信号量的类型定义

每个信号量至少须记录两个信息：信号量的值和等待该信号量的进程队列。它的类型定义如下：（用类PASCAL语言表述）

1. semaphore = record 
2.     value: integer; 
3.     queue: ^PCB; 
4. end; 

其中PCB是进程控制块，是操作系统为每个进程建立的数据结构。

s.value>=0时，s.queue为空； 

s.value<0时，s.value的绝对值为s.queue中等待进程的个数；

2． PV原语

对一个信号量变量可以进行两种原语操作：p操作和v操作，定义如下：

1. procedure p(var s:samephore); 
2.      { 
3.         s.value=s.value-1;
4.         if (s.value<0) asleep(s.queue); 
5.      } 
6. procedure v(var s:samephore); 
7.      { 
8.         s.value=s.value+1;
9.         if (s.value<=0) wakeup(s.queue); 
10.      }

其中用到两个标准过程：

  asleep(s.queue);执行此操作的进程的PCB进入s.queue尾部，进程变成等待状态

  wakeup(s.queue);将s.queue头进程唤醒插入就绪队列

s.value初值为1时，可以用来实现进程的互斥。

p操作和v操作是不可中断的程序段，称为原语。如果将信号量看作共享变量，则pv操作为其临界区，多个进程不能同时执行，一般用硬件方法保证。一个信号量只能置一次初值，以后只能对之进行p操作或v操作。

由此也可以看到，信号量机制必须有公共内存，不能用于分布式操作系统，这是它最大的弱点。

二. 实例

1． 生产者-消费者问题（有buffer）

问题描述：

  一个仓库可以存放K件物品。生产者每生产一件产品，将产品放入仓库，仓库满了就停止生产。消费者每次从仓库中去一件物品，然后进行消费，仓库空时就停止消费。

解答：

  进程：Producer - 生产者进程，Consumer - 消费者进程 

  共有的数据结构：

     buffer: array [0..k-1] of integer; 

     in,out: 0..k-1; 

       — in记录第一个空缓冲区，out记录第一个不空的缓冲区 

     s1,s2,mutex: semaphore; 

       — s1控制缓冲区不满,s2控制缓冲区不空,mutex保护临界区；

         初始化s1=k,s2=0,mutex=1

1. producer（生产者进程）： 
2.    Item_Type item; 
3.   { 
4.      while (true) 
5.      { 
6.        produce(&item);
7.        p(s1); 
8.        p(mutex); 
9.        buffer[in]:=item; 
10.        in:=(in+1) mod k; 
11.        v(mutex); 
12.        v(s2); 
13.      } 
14.   } 
16. consumer（消费者进程）： 
17.    Item_Type item; 
18.   { 
19.      while (true) 
20.      { 
21.        p(s2); 
22.        p(mutex); 
23.         item:=buffer[out]; 
24.         out:=(out+1) mod k; 
25.         v(mutex); 
26.         v(s1); 
27.        consume(&item);
28.      } 
29.    } 

2． 第一类读-写者问题

问题描述：

  一些读者和一些写者对同一个黑板进行读写。多个读者可同时读黑板，但一个时刻只能有一个写者，读者写者不能同时使用黑板。对使用黑板优先级的不同规定使读者-写者问题又可分为几类。第一类问题规定读者优先级较高，仅当无读者时允许写者使用黑板。

解答：

  进程：writer - 写者进程，reader - 读者进程 

  共有的数据结构：

     read_account:integer; 

     r_w,mutex: semaphore; 

       — r_w控制谁使用黑板,mutex保护临界区，初值都为1

1. reader - (读者进程）： 
2.   { 
3.      while (true) 
4.      { 
5.        p(mutex);
6.        read_account++; 
7.        if(read_account=1) p(r_w); 
8.        v(mutex); 
9.        read(); 
10.        p(mutex); 
11.        read_account--; 
12.        if(read_account=0) v(r_w);; 
13.        v(mutex); 
14.      } 
15.   } 
17. writer - (写者进程）： 
18.   { 
19.      while (true) 
20.      { 
21.        p(mutex); 
22.         write(); 
23.         v(mutex); 
24.      } 
25.    }

3． 哲学家问题

问题描述：

  一个房间内有5个哲学家，他们的生活就是思考和进食。房间里有一张圆桌，中间放着一盘通心粉（假定通心粉无限多）。桌子周围放有五把椅子，分别属于五位哲学家每两位哲学家之间有一把叉子，哲学家进食时必须同时使用左右两把叉子。

解答：

  进程：philosopher - 哲学家 

  共有的数据结构&过程：

     state: array [0..4] of (think,hungry,eat); 

     ph: array [0..4] of semaphore; 

       — 每个哲学家有一个信号量，初值为0 

     mutex: semaphore; 

       — mutex保护临界区，初值=1

1. procedure test(i:0..4); 
2.      { 
3.        if ((state[i]=hungry) and (state[(i+1)mod 5]<>eating)
4.        and (state[(i-1)mod 5]<>eating))
5.        { state[i]=eating; 
6.           V(ph[i]); 
7.        }
8.      } 
10. philosopher(i:0..4)： 
11.   { 
12.      while (true) 
13.      { 
14.        think();
15.        p(mutex); 
16.        state[i]=hungry; 
17.        test(i); 
18.        v(mutex); 
19.        p(ph[i]); 
20.        eat(); 
21.        p(mutex); 
22.        state[i]=think; 
23.        test((i-1) mod 5); 
24.        test((i+1) mod 5); 
25.        v(mutex); 
26.      } 
27.   }