PV原语详解

顺其自然~

已于 2023-04-14 11:23:49 修改

阅读量7.4k

点赞数 27

文章标签： PV原语

于 2018-10-29 21:41:35 首次发布

本文链接：https://blog.csdn.net/fuhanghang/article/details/83513779

版权

PV原语通过操作信号量来处理进程间的同步与互斥的问题。其核心就是一段不可分割不可中断的程序。信号量的概念1965年由著名的荷兰计算机科学家Dijkstra提出，其基本思路是用一种新的变量类型(semaphore)来记录当前可用资源的数量（可想象成停车场，共m个车位，来一辆车，则管理员用现有车位-1做测试，如果减1之后发现大于等于0，则把车放进去；如果减1之后发现小于0，则从门口排队等着；走一辆车，则剩余车位+1，如果小于等于0，则原先等待的车继续等，如果大于0，则把原先等待的车放一辆进去）。信号量为0或正，则代表空闲资源数；为负则代表等待进程数。

semaphore有两种实现方式：

1) semaphore的取值必须大于或等于0。0表示当前已没有空闲资源，而正数表示当前空闲资源的数量；

2) semaphore的取值可正可负，负数的绝对值表示正在等待进入临界区的进程个数。

信号量是由操作系统来维护的，用户进程只能通过初始化和两个标准原语(P、V原语)来访问。初始化可指定一个非负整数，即空闲资源总数。

P原语：P是荷兰语Proberen(测试)的首字母。为阻塞原语，负责把当前进程由运行状态转换为阻塞状态，直到另外一个进程唤醒它。操作为：申请一个空闲资源(把信号量减1)，若成功，则退出；若失败，则该进程被阻塞；

V原语：V是荷兰语Verhogen(增加)的首字母。为唤醒原语，负责把一个被阻塞的进程唤醒，它有一个参数表，存放着等待被唤醒的进程信息。操作为：释放一个被占用的资源(把信号量加1)，如果发现有被阻塞的进程，则选择一个唤醒之。

P原语操作的动作是：

(1)sem减1；

(2)若sem减1后仍大于或等于零，则进程继续执行；

(3)若sem减1后小于零，则该进程被阻塞后进入与该信号相对应的队列中，然后转进程调度。

V原语操作的动作是：

(1)sem加1；

(2)若相加结果大于零，则进程继续执行；

(3)若相加结果小于或等于零，则从该信号的等待队列中唤醒一等待进程，然后再返回原进程继续执行或转进程调度。

PV操作对于每一个进程来说，都只能进行一次，而且必须成对使用。在PV原语执行期间不允许有中断的发生。

具体PV原语对信号量的操作可以分为三种情况：

1) 把信号量视为一个加锁标志位，实现对一个共享变量的互斥访问。

实现过程：

P(mutex); // mutex的初始值为1 
访问该共享数据;
V(mutex);
非临界区;

2) 把信号量视为是某种类型的共享资源的剩余个数，实现对一类共享资源的访问。

实现过程：

P(resource); // resource的初始值为该资源的个数N 
使用该资源；
V(resource);
非临界区;

3) 把信号量作为进程间的同步工具

实现过程：

临界区C1;
P(S);
V(S);
临界区C2;

举例说明：

例1：某超市门口为顾客准备了100辆手推车，每位顾客在进去买东西时取一辆推车，在买完东西结完帐以后再把推车还回去。试用P、V操作正确实现顾客进程的同步互斥关系。分析：把手推车视为某种资源，每个顾客为一个要互斥访问该资源的进程。因此这个例子为PV原语的第二种应用类型。

解：

semaphore S_CartNum;    // 空闲的手推车数量，初值为100
void  consumer(void)    // 顾客进程
{     
   P(S_CartNum);
   买东西;
   结帐;
   V(S_CartNum);
}

例2：桌子上有一个水果盘，每一次可以往里面放入一个水果。爸爸专向盘子中放苹果，儿子专等吃盘子中的苹果。把爸爸、儿子看作二个进程，试用P、V操作使这两个进程能正确地并发执行。

分析：爸爸和儿子两个进程相互制约，爸爸进程执行完即往盘中放入苹果后，儿子进程才能执行即吃苹果。因此该问题为进程间的同步问题。

解：

semaphore  S_PlateNum;  // 盘子容量，初值为1
semaphore  S_AppleNum;  // 苹果数量，初值为0
void  father( )  // 父亲进程 {
    while(1)
    {        
        P(S_PlateNum);//先减少盘子数，如果儿子不拿走苹果，则盘子数为0，父亲就要等待
        往盘子中放入一个苹果;
        V(S_AppleNum);
    }  
}
void  son( )   // 儿子进程 {
    while(1)
    {        
        P(S_AppleNum);//先减少苹果数，如果父亲不放苹果，则苹果数为0，儿子就要等待
        从盘中取出苹果;
        V(S_PlateNum);
        吃苹果；
    }  
}

另附用PV原语解决进程同步与互斥问题的例子:

例3：两个进程PA、PB通过两个FIFO(先进先出)缓冲区队列连接(如图)

PA从Q2取消息，处理后往Q1发消息；PB从Q1取消息，处理后往Q2发消息，每个缓冲区长度等于传送消息长度。 Q1队列长度为n，Q2队列长度为m. 假设开始时Q1中装满了消息，试用P、V操作解决上述进程间通讯问题。

解：

// Q1队列当中的空闲缓冲区个数，初值为0 semaphore  S_BuffNum_Q1;  
// Q2队列当中的空闲缓冲区个数，初值为m  semaphore  S_BuffNum_Q2;   
// Q1队列当中的消息数量，初值为n  semaphore  S_MessageNum_Q1;
// Q2队列当中的消息数量，初值为0  semaphore  S_MessageNum_Q2;
void PA( ) {
    while(1)
    {         
      P(S_MessageNum_Q2);//没有则阻塞
        从Q2当中取出一条消息;
      V(S_BuffNum_Q2);//唤醒PB发消息(如果PB发消息已阻塞)
        处理消息;
        生成新的消息;
      P(S_BuffNum_Q1);//没有则阻塞
        把该消息发送到Q1当中;
      V(S_MessageNum_Q1);//唤醒PB取消息（如果PB取消息已阻塞）
    }  
}
void PB( ) {
    while(1)
    {        
       P(S_MessageNum_Q1);//没有则阻塞
        从Q1当中取出一条消息;
       V(S_BuffNum_Q1);//唤醒PA发消息(如果PA发消息已阻塞)
        处理消息;
        生成新的消息;
       P(S_BuffNum_Q2);//没有则阻塞
        把该消息发送到Q2当中;
       V(S_MessageNum_Q2);//唤醒PA取消息（如果PA取消息已阻塞）
    }  
}

例4：《操作系统》课程的期末考试即将举行，假设把学生和监考老师都看作进程，学生有N人，教师1人。考场门口每次只能进出一个人，进考场的原则是先来先进。当N个学生都进入了考场后，教师才能发卷子。学生交卷后即可离开考场，而教师要等收上来全部卷子并封装卷子后才能离开考场。

(1)问共需设置几个进程?

(2)请用P、V操作解决上述问题中的同步和互斥关系。

解：

semaphore  S_Door;         // 能否进出门，初值1
semaphore  S_StudentReady; // 学生是否到齐，初值为0
semaphore  S_ExamBegin;   // 开始考试，初值为0
semaphore  S_ExamOver;    // 考试结束，初值为0
int nStudentNum = 0;       // 学生数目
semaphore  S_Mutex1;       //互斥信号量，初值为1
int  nPaperNum = 0;       // 已交的卷子数目
semaphore  S_Mutex2;       //互斥信号量，初值为1
void  student( ) {
    P(S_Door);
      进门;     
    V(S_Door);
    P(S_Mutex1)；
      nStudentNum ++;   // 增加学生的个数
      if(nStudentNum == N){  
        V(S_StudentReady);
      }
    V(S_Mutex1);
    P(S_ExamBegin);  // 等老师宣布考试开始
      考试中…
      交卷;
    P(S_Mutex2);
      nPaperNum ++;    // 增加试卷的份数
      if(nPaperNum == N){ 
        V(S_ExamOver);
      }
    V(S_Mutex2);
    P(S_Door);
      出门;
    V(S_Door);
}
void  teacher( ) {
    P(S_Door);
      进门;     
    V(S_Door);
    P(S_StudentReady);    //等待最后一个学生来唤醒
      发卷子;
      for(i = 1; i <= N; i++)   
      V(S_ExamBegin);
      P(S_ExamOver);    //等待考试结束
        封装试卷;
        P(S_Door);
        出门;         
      V(S_Door);
}

例 5：某商店有两种食品A和B，最大数量均为m个。该商店将A、B两种食品搭配出售，每次各取一个。为避免食品变质，遵循先到食品先出售的原则。有两个食品公司分别不断地供应A、B两种食品(每次一个)。为保证正常销售，当某种食品的数量比另一种的数量超过k(k<m)个时，暂停对数量大的食品进货，补充数量少的食品。

(1) 问共需设置几个进程?

(2) 用P、V操作解决上述问题中的同步互斥关系。

解：

semaphore  S_BuffNum_A;  //A的缓冲区个数, 初值m
semaphore  S_Num_A;      // A的个数，初值为0
semaphore  S_BuffNum_B;  //B的缓冲区个数, 初值m
semaphore  S_Num_B;      // B的个数，初值为0
void  Shop( ) {
    while(1)
    {         
        P(S_Num_A);
        P(S_Num_B);
          分别取出A、B食品各一个;
        V(S_BuffNum_A);
        V(S_BuffNum_A);
          搭配地销售这一对食品;
    }  
}
// “A食品加1，而B食品不变”这种情形允许出现的次数(许可证的数量)，其值等于//k-(A-B)，初值为k
semaphore  S_A_B;
// “B食品加1，而A食品不变”这种情形允许出现的次数(许可证的数量)，其值等于//k-(B-A)，初值为k
semaphore  S_B_A;
void  Producer_A( ) {
    while(1)
    {         
      生产一个A食品;
      P(S_BuffNum_A);
      P(S_A_B);
      向商店提供一个A食品;
      V(S_Num_A);
      V(S_B_A);
    }  
}
void  Producer_B( ) {
    while(1)
    {
        生产一个B食品;
        P(S_BuffNum_B);
        P(S_B_A);
        向商店提供一个B食品;
        V(S_Num_B);
        V(S_A_B);
    }  
}

例6：在一栋学生公寓里，只有一间浴室，而且这间浴室非常小，每一次只能容纳一个人。公寓里既住着男生也住着女生，他们不得不分享这间浴室。因此，楼长制定了以下的浴室使用规则：

(1)每一次只能有一个人在使用；

(2)女生的优先级要高于男生，即如果同时有男生和女生在等待使用浴室，则女生优先；

(3)对于相同性别的人来说，采用先来先使用的原则。

假设：

(1)当一个男生想要使用浴室时，他会去执行一个函数boy_wants_to_use_bathroom，当他离开浴室时，也会去执行另外一个函数boy_leaves_bathroom；

(2)当一个女生想要使用浴室时，会去执行函数girl_wants_to_use_bathroom，当她离开时, 也会执行函数girl_leaves_bathroom;

问题：请用信号量和P、V操作来实现这四个函数（初始状态：浴室是空的）。

解：

信号量的定义：
semaphore  S_mutex;  // 互斥信号量，初值均为1
semaphore  S_boys;   // 男生等待队列，初值为0
semaphore  S_girls; // 女生等待队列，初值为0
普通变量的定义：
int  boys_waiting = 0;  // 正在等待的男生数；
int  girls_waiting = 0; // 正在等待的女生数；
int  using = 0;         // 当前是否有人在使用浴室;
void  boy_wants_to_use_bathroom ( ) {
    P(S_mutex);
    if((using == 0) && (girls_waiting == 0))
    {
        using  =  1;
        V(S_mutex);
    }
    else
    {
        boys_waiting ++;
        V(S_mutex);
        P(S_boys);
    }
}
void  boy_leaves_bathroom ( ) {
    P(S_mutex);
    if(girls_waiting  >  0)  // 优先唤醒女生
    {
        girls_waiting --;
        V(S_girls);
    }
    else  if(boys_waiting  >  0)
    {
        boys_waiting --;
        V(S_ boys);
    }
    else   
        using  =  0;     // 无人在等待
    V(S_mutex);
}
void  girl_wants_to_use_bathroom ( ) {
    P(S_mutex);
    if(using == 0)
    {
        using  =  1;
        V(S_mutex);
    }
    else
    {
        girls_waiting ++;
        V(S_mutex);
        P(S_girls);
    }
}
void  girl_leaves_bathroom ( ) {
    P(S_mutex);
    if(girls_waiting  >  0)  // 优先唤醒女生
    {
        girls_waiting --;
        V(S_girls);
    }
    else  if(boys_waiting  >  0)
    {
        boys_waiting --;
        V(S_ boys);
    }
    else   
        using  =  0;     // 无人在等待
    V(S_mutex);
}