一文搞懂操作系统进程同步的几种机制(含现实案列)

进程P1              进程P2           ……          进程Pn
……                ……                           ……
P（S）；P（S）；P（S）；
临界区；临界区；临界区；
V（S）；V（S）；V（S）；
……                ……             ……          ……

empty——表示缓冲区是否为空，初值为1。
   full——表示缓冲区中是否为满，初值为0。
生产者进程
while(TRUE){
生产一个产品;
     P(empty);
     产品送往Buffer;
     V(full);
}
消费者进程
while(True){
P(full);
   从Buffer取出一个产品;
   V(empty);
   消费该产品;
  }

empty——表示缓冲区是否为空，初值为n。
full——表示缓冲区中是否为满，初值为0。
    设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指
，指向下一个可用的缓冲区。
生产者进程
while(TRUE){
     生产一个产品;
     P(empty);
     产品送往buffer（in）；
     in=(in+1)mod n；
     V(full);
}
消费者进程
while(TRUE){
 P(full);
   从buffer（out）中取出产品；
   out=(out+1)mod n；
   V(empty);
   消费该产品;
  }

empty——表示缓冲区是否为空，初值为n。
full——表示缓冲区中是否为满，初值为0。
mutex1——生产者之间的互斥信号量，初值为1。
mutex2——消费者之间的互斥信号量，初值为1。
    设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。
生产者进程
while(TRUE){
     生产一个产品;
     P(empty);
     P(mutex1)；
     产品送往buffer（in）；
     in=(in+1)mod n；
     V(mutex1);
     V(full);
}
消费者进程
while(TRUE){
 P(full)
   P(mutex2)；
   从buffer（out）中取出产品；
   out=(out+1)mod n；
   V（mutex2）；
   V(empty);
   消费该产品;
   }

int S＝1;
int Sa＝0;
int So＝0;
      main()
      {
        cobegin
            father();      /*父亲进程*/
            son();        /*儿子进程*/
            daughter();    /*女儿进程*/
        coend
    ｝
    father()
    {
        while(1)
          {
            P(S);
            将水果放入盘中;
            if（放入的是桔子）V(So);
            else  V(Sa);
           }
     }
    son()
    {
        while(1)
          {
             P(So);
             从盘中取出桔子;
             V(S);
             吃桔子;
            ｝
    }
    daughter()
    {
         while(1)
            {
              P(Sa);
              从盘中取出苹果;
              V(S);
              吃苹果;
            ｝
｝

A()                B()                  C()                 D()
 {                 {                    {                  {
  [1];                [3];                  [5];                 [7];
  read F;             read F;                read F;              read F;
  [2];                [4];                  [6];                 [8];
 }                  }                    }                  }

管程：buffer=MODULE; 
（假设已实现一基本管程monitor，提供enter,leave,signal,wait等操作）
notfull,notempty:condition; // notfull控制缓冲区不满,notempty控制缓冲区不空；
count,in,out: integer; 　　  // count记录共有几件物品，in记录第一个空缓冲区，out记录第一个不空的缓冲区 
buf:array [0..k-1] of item_type; 
define deposit,fetch; 
use monitor.enter,monitor.leave,monitor.wait,monitor.signal;
procedure deposit(item); 
{ 
　　if(count=k) monitor.wait(notfull); 
　　buf[in]=item; 
　　in:=(in+1) mod k; 
　　count++; 
　　monitor.signal(notempty); 
} 
procedure fetch:Item_type; 
{ 
　　if(count=0) monitor.wait(notempty); 
　　item=buf[out]; 
　　in:=(in+1) mod k; 
　　count--; 
　　monitor.signal(notfull); 
　　return(item); 
} 
{ 
count=0; 
in=0; 
out=0; 
} 
进程：producer,consumer; 
producer（生产者进程）：
Item_Type item; 
{ 
　　while (true) 
　　{ 
　　　　produce(&item); 
　　　　buffer.enter(); 
　　　　buffer.deposit(item); 
　　　　buffer.leave(); 
　　} 
} 
consumer（消费者进程）：
Item_Type item; 
{ 
　　while (true) 
　　{ 
　　　　buffer.enter(); 
　　　　item=buffer.fetch(); 
　　　　buffer.leave(); 
　　　　consume(&item); 
　　} 
}

wait(semaphore *S) {
    S->value--;
 if(S->value < 0) {
        add this process to S->list;
        block();
    }
}

signal(semaphore *S) {
    S->value++;
 if(S->value <= 0) {
        remove a process P from S->list;
        wakeup(P);
    }
}

do{
    wait(full);
    wait(mutex);
    ...
 //remove an item from buffer to nextc
    ...
    signal(mutex);
    signal(empty);
    ...
 //consume the item in nextc
    ...
} while(TRUE);

do{
    wait(wrt);
    ...
 //writing is performed 
    ...
    signal(wrt);
} while(TRUE);

do{
    wait(mutex);//确保与signal(mutex)之间的操作不会被其他读者打断
    readcount++;
 if(readcount == 1)
        wait(wrt);
    signal(mutex);
    ...
 //reading is performed
    ...
    wait(mutex);
    readcount--;
 if(readcount == 0)
        signal(wrt);
    signal(mutex);
} while(TRUE);

do{
    wait(chopstick[i]);
    wait(chopstick[(i+1)%5]);
    ...
 //eating
    ...
    signal(chopstick[i]);
    signal(chopstick[(i+1)%5]);
    ...
 //thinking
    ...
} while(TRUE);

do{
    wait(mutex);
    wait(chopstick[i]);
    wait(chopstick[(i+1)%5]);
    signal(mutex);
    ...
 //eating  
    ...
    wait(mutex);
    signal(chopstick[i]);
    signal(chopstick[(i+1)%5]);
    signal(mutex);
    ...
 //thinking  
    ...
} while(TRUE);