信号量和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.   } 
  15. consumer(消费者进程): 
  16.    Item_Type item; 
  17.   
  18.      while (true) 
  19.      { 
  20.        p(s2); 
  21.        p(mutex); 
  22.         item:=buffer[out]; 
  23.         out:=(out+1) mod k; 
  24.         v(mutex); 
  25.         v(s1); 
  26.        consume(&item);
  27.      } 
  28.    } 
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.   } 
  16. writer - (写者进程): 
  17.   
  18.      while (true) 
  19.      { 
  20.        p(mutex); 
  21.         write(); 
  22.         v(mutex); 
  23.      } 
  24.    }
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.      } 
  9. philosopher(i:0..4): 
  10.   
  11.      while (true) 
  12.      { 
  13.        think();
  14.        p(mutex); 
  15.        state[i]=hungry; 
  16.        test(i); 
  17.        v(mutex); 
  18.        p(ph[i]); 
  19.        eat(); 
  20.        p(mutex); 
  21.        state[i]=think; 
  22.        test((i-1) mod 5); 
  23.        test((i+1) mod 5); 
  24.        v(mutex); 
  25.      } 
  26.   }

你可能感兴趣的:(数据结构,生活,buffer,语言,pascal,产品)