进程相互作用之信号量PV操作及其代码实现

目录

• 信号量PV操作
  • 基本介绍
  • 数据结构
  • 解决进程互斥问题
  • 解决进程同步问题
• 代码实现（以同步问题为例）

信号量PV操作

基本介绍

• 信号量(Semaphore)：是表示资源的实体，是一个与队列有关的整型变量，其值仅能由P、V操作改变。
• 信号量分为:公用信号量和私用信号量。
• 公用信号量:用于实现进程间的互斥，初值通常设为1，它所联系的一组并发进程均可对它实施P、V操作;
• 私用信号量:用于实现进程间的同步，初始值通常设为0或n，允许拥有它的进程对其实施Р操作。

数据结构

信号量的数据结构:

struct semaphore{
    int value;         //系统中的资源数
    pointer_PCB queue; //阻塞进程队列
};//PCB表示进程控制块
//声明
semaphore s;

PV操作

P(s){//申请资源
    if(--s.value<0){
        该进程设置为阻塞态
        将该进程的PCB插入阻塞队列s.queue末尾
    }
}
V(s){//释放资源
    if(++s.value <= 0){
        唤醒相应阻塞队列s.queue中等待的一个进程
        改变其状态为就绪态
        并将其插入就绪队列
    }
}

s. value >= 0时，其值表示还有可用的资源数;

s. value < 0时，其绝对值表示有多少个进程因申请该信号量表示的资源，得不到而进入阻塞态;

解决进程互斥问题

把P₁-P₃进程的互斥操作都包括在一个PV操作对中

由P₂进入

举例1：

启发：写并发进程的时候需要明确互斥区

1. 不同进程未进入互斥区时可以并发
2. 不同进程进入互斥区时要用PV操作控制

解决进程同步问题

在同步问题中信号量的value值相比于“资源”资源来说，理解为“权限”会更合适，在一个同步问题中，一个进程的执行权限是由它的前驱进程赋予的

代码实现（以同步问题为例）

为了便于实现，将程序的运行操作也封装到PV操作中，即

• 如果P操作为信号量申请到权限，那么直接执行信号量所对应的进程
• 如果V操作赋予了信号量权限且信号量的阻塞队列中有进程，那么直接执行阻塞队列中的进程
  
  

代码如下：【本人才疏学浅，如有不足恳请斧正】

#include<iostream>
#include<string>
#include<queue>
using namespace std;
/*定义类：process表示一个进程*/
class process{
public :
    /*构造函数*/
    process() = default;
    process(const string &name) : process_name(name){}
    process(const process &p) :
        process_name(p.process_name){}
    /*成员函数*/
    //执行进程
    void _on(){cout<<process_name+": on"<<endl;}
    //关闭进程
    void _off() {cout<<process_name+": of"<<endl;}
    //进程名
    string process_name;
};

/*定义类：semaphore表示信号量*/
/*一个信号量控制一个进程*/
class semaphore{
/*友元声明：确保PV操作可以访问semaphore私有成员*/
friend void P(semaphore &s);
friend void V(semaphore &s);
public:
    /*构造函数：参数为信号量控制的进程*/
    semaphore(const process &p) :
        present(p){};
private :
    int value = 0;    //同步问题value初始化为0
    process present;  //该信号量控制的进程
    queue<process> blocked_processes;  //阻塞队列
};

/*P操作：申请资源（权限）*/
void P(semaphore &s){
    --s.value;//申请
    if(s.value<0){//无资源(权限)：进程进入阻塞队列
        //打印提示信息
        cout<<s.present.process_name+" is blocked"<<endl;
        //将进程加入阻塞队列
        s.blocked_processes.push(s.present);
    }
    else{//有资源：直接执行
        s.present._on();
    }
}
/*V操作：返回资源（给予权限）*/
void V(semaphore &s){
    ++s.value;//赋予
    if(s.value>=0){//如果阻塞队列有进程：唤醒阻塞进程
        if(!s.blocked_processes.empty()){
            s.blocked_processes.front()._on();
            s.blocked_processes.pop();
        }
    }
    //否则什么也不做
}
//开车进程
process speed_up("speed_up");
//开门进程
process open_door("open_door");
//用两个信号量分别控制开车进程和开门进程
semaphore OpenDoor(open_door), Speed_Up(speed_up);

int main(){
    V(OpenDoor); //赋予开车门的权限
    P(OpenDoor); //申请权限：有权限，可以开，打印open_door: on
    P(OpenDoor); //申请权限：无权限，开不了门，进入开门阻塞队列
    P(Speed_Up); //申请权限：无权限，开不了车，进入开车阻塞队列
    V(Speed_Up); //赋予权限：执行开车阻塞队列进程，打印speed_up: on
    V(OpenDoor); //赋予权限：执行开门阻塞队列进程，打印open_door: on
    return 0;
}

运行结果：