操作系统-PV操作的原理和几种常见问题

信号量是一种变量类型，用一个记录型数据结构表示，有两个分量：信号量的值和信号量队列指针

除了赋初值外，信号量仅能通过同步原语PV对其进行操作

s.value为正时，此值为封锁进程前对s信号量可施行的P操作数，即s代表实际可用的物理资源

s.value为负时，其绝对值为对信号量s实施P操作而被封锁并进入信号量s等待队列的进程数，即登记排列在s信号量队列之中等待的进程个数

s.value为0时，无资源且无进程等待

信号量按其取值可分为二值信号量和一般信号量（计数信号量），记录型信号量和PV操作定义为如下数据结构和不可中断过程：

typedef struct semaphore {
    int value;
    struct pcb *list; //信号量队列指针
}
void P(semaphore s){
    s.value--;
    if(s.value<) sleep(s.list); //若信号量值小于0，执行P操作的进程调用sleep(s.list)阻塞自己，被置成等待信号量s状态并移入s信号量队列，转向进程调度程序
}
void V(semaphore s){
    s.value++;
    if(s.value<=) wakeup(s.list); //若信号量小于等于0，则调用wakeup(s.list)从信号量s队列中释放一个等待信号量s的进程并转换成就绪态，进程则继续运行
}

二值信号量虽然仅能取值0、1，但它和其它记录型信号量有一样的表达能力

• 机票问题

注意：（1）P操作与V操作在执行路径上必须一一对应，有一个P操作就有一个V操作；（2）输出一张票的操作不应放在临界区内

int A[m];
Semaphore s = ;
cobegin
process Pi {
    int Xi;
    Li:按旅客定票要求找到A[j]；
    P(s)；
    Xi = A[j];
    If (Xi>=) { Xi=Xi-; A[j]=Xi;V(s); 输出一张票；}
    else {V(s); 输出票已售完;}
    goto Li;
    }
coend;

只有相同航班的票数才是相关的临界资源，所以用一个信号量s处理全部机票会影响进程并发度

可以让每一个航班都有自己的临界区，把信号量改为s[m]

int A[m];
Semaphore s[m];    //每一个航班都有自己的临界区
For (int j=;j<m;i++) s[j] = ;
cobegin
process Pi {
    int Xi;
    L1:按旅客定票要求找到A[j]；
    P(s[j])；
    Xi = A[j];
    If (Xi>=) { Xi=Xi-; A[j]=Xi;V(s[j]); 输出一张票；
    } else {V(s[j]); 输出票已售完；}
    goto L1;
    }
coend;

• 生产者消费者问题

（1）1生产者1消费者1缓冲区问题

int B;
semaphore sput = ； /* 可以使用的空缓冲区数 */
semaphore sget = ; /* 缓冲区内可以使用的产品数 */
process producer {
    L1:
    produce a product；
    P(sput);
    B = product；
    V(sget);
    goto L1;
}
process consumer {
    L2:
    P(sget);
    product = B；
    V(sput);
    consume a product；
    goto L2;
}

（2）1生产者1消费者N缓冲区问题

必须引入放入和取出产品的循环队列指针putptr指针和getptr指针进行管理，因为只有1生产者1消费者所以它们不需要是共享变量

int B[k]; // 共享缓冲区队列
semaphore sput = N；  //可以使用的空缓冲区数
semaphore sget = ;  //缓冲区内可以使用的产品数
int putptr = getptr = ;
process producer {
    L1:produce a product；
    P(sput);
    B[putptr] = product；
    putptr = (putptr + ) mod k;
    V(sget);
    goto L1;
}
process consumer {
    L2:P(sget);
    product = B[getptr]；
    getptr = (getptr + ) mod k;
    V(sput);
    consume a product；
    goto L2;
}

️（3）N生产者N消费者N缓冲区问题

必须引入新的信号量s1和s2对putptr指针和getptr指针进行管理

int B[k];
semaphore sput = N； /* 可以使用的空缓冲区数 */
semaphore sget = ; /* 缓冲区内可以使用的产品数 */
int putptr = getptr = ;
semaphore s1 = s2 = ； /* 互斥使用putptr、getptr */
process producer_i {
    L1:produce a product；
   P(sput);
    P(s1);
    B[putptr] = product；
    putptr = ( putptr +  ) mod k;
   V(s1);
    V(sget);
    goto L1;
}
process consumer_j {
    L2:P(sget);
    P(s2);
    Product = B[getptr]；
    getptr = ( getptr +  ) mod k;
    V(s2);
    V(sput);
    consume a product；
    goto L2;
}

若要求一个消费者取10次，其它消费者才能开始取，则需要再增加一个信号量mutex1并对消费者进程进行改造，循环10次后再V(mutex1)。

这里通过一个互斥信号量mutex2互斥访问缓冲区，而不是像前面那样通过两个互斥信号量s1和s2分别互斥使用缓冲区存指针putptr、取指针getptr

process consumer_j {
    P(mutex1);
    for(int i=; i<; i++){
        P(full);
        P(mutex2);
        互斥访问缓冲区；
        V(mutex2);
        V(empty);
    }
    V(mutex1);
}

（4）苹果橘子问题

父亲只放评估、母亲只放橙子；儿子只吃橙子、女儿只吃苹果

同步关系1：有苹果

同步关系2：有橘子

同步关系3：有空位

Semaphore sp； /* 盘子里可以放几个水果*/
Semaphore sg1; /* 盘子里有桔子*/
Semaphore sg2; /* 盘子里有苹果*/
sp = ; /* 盘子里允许放入一个水果*/
sg1 = ; /* 盘子里没有桔子*/
sg2 = ; /* 盘子里没有苹果*/
process father {
L1: 削一个苹果；
    P(sp);
    把苹果放入plate；
    V(sg2);
    goto L1;
}
process mother {
    L2: 剥一个桔子；
    P(sp);
    把桔子放入plate；
    V(sg1);
    goto L2;
}
process son {
    L3: P(sg1);
    从plate中取桔子；
    V(sp);
    吃桔子；
    goto L3;
}
process daughter {
    L4: P(sg2);
    从plate中取苹果；
    V(sp);
    吃苹果；
    goto L4;
}

（5）吸烟者问题

三个消费者各有一种材料、缺另外两种材料，供应者每次随机供应两种不同材料

想法：生产者每次供应两种不同材料，其实可以理解为有三种不同的生产材料提供方式，分别供三种消费者消费

int random;
Semaphore offer1 = offer2 = offer3 = ；
Semaphore finish = ;
process producer(){
    while(){
        random = 任意随机整数;
        random = random % ；
        P(finish);
        对应两种材料放在桌子上；
        if(random==) V(offer1);
        else if(random==) V(offer2);
        else V(offer3);
    }
}
process consumer_1(){
    while(){
        P(offer1);
        拿自己缺的那两种材料；
        卷成烟抽掉；
        V(finish);
    }
}

（6）1生产者2消费者N缓冲区，生产者随机生成正整数，2个消费者分别取奇数和偶数

思路：这个问题和抽烟者问题很类似，关键是要定义缓冲区里有奇数的互斥信号量odd、缓冲区里有偶数的互斥信号量even。每次生产者随机生成一个数之后，判断奇偶，分别V(odd)和V(even)

• 哲学家就餐问题

Semaphore fork[];
for (int i = ; i < ; i++)
    fork[i] = ;
cobegin
process philsopher_i() {
    while (true) {
        think();
        P(fork[i]);
        P(fork[(i+)%]);
        eat();
        V(fork[i]);
        V(fork[(i+)%]);
    }
}
coend

如果5位哲学家同时拿起他们左手/右手的叉子，将出现死锁，可以：

（1）至多允许四个哲学家同时拿叉子

（2）奇数号哲学家先取左边叉子，再取右边叉子；偶数号哲学家则相反

（3）每位哲学家取到手边两把叉子才开始吃，否则一把也不取：可以通过引入互斥信号量mutex每次只允许一个哲学家拿叉子

Semaphore fork[];
for (int i = ; i < ; i++)
    fork[i] = ;
Semaphore mutex = ;
cobegin
process philsopher_i() {
    while(true){
       P(mutex);
        P(fork[i]);
        P(fork[(i+)%]);
       V(mutex);
        eat();
        V(fork[i]);
        V(fork[(i+)%]);
    }
}
coend

• 写者问题

一次只允许一个写者写，但可以N个读者同时读。写者完成写操作前不允许其它写者、读者操作

引入表示是否允许写的信号量writeblock，相当于任何进程在工作的时候都不允许写。不过单纯引入信号量不能解决此问题，还必须引入计数器readcount对读进程进行计数，读之前检查计数器，如果为1（自己是唯一的读进程）才需要P(writeblock)，读之后检查计数器，如果为0（当前已无读进程）则需要V(writeblock)。

mutex是用于对计数器readcount操作的互斥信号量

int readcount = ;
Semaphore writeblock =  ;
Semaphore mutex = ;
cobegin
process read_i() {
    P(mutex);
    readcount++;
    if(readcount==) P(writeblock); //自己是唯一的读进程，写者在写文件时自己不能开始读，自己开始读后不允许写操作
    V(mutex);
    /*读文件*/
    P(mutex);
    readcount-—;
    if(readcount==) V(writeblock); //自己是唯一的读进程，读文件完成后允许写操作
    V(mutex);
}
process write_j() {
    P(writeblock);
    /*写文件*/
    V(writeblock)；
}
coend

此写法读者优先，当存在读者时写者将被延迟。且只要有一个读者活跃，随后而来的读者都将被允许访问文件，从而导致写者长时间等待。

改进方法：增加信号量，确保当一个写进程声明想写时，不允许后面的新读者访问共享文件。

• 男女共浴问题、汽车过桥问题

这个问题的关键是设置一把性别锁mutex，第一个到的男人要负责抢这把锁，因此mutex的PV操作必须放在修改mancount的临界区内。一旦男人抢到了这把锁，试图抢这把锁的女人就会停留在womancount的临界区内出不来，而每次又只允许一个女人进入womancount的临界区。

最后一个走的男人要负责把这把锁释放掉。

Semaphore mutex;
Semaphore mutex_man = mutex_woman= ;
int mancount = womancount =;
Process man(){
    P(mutex_man)
    mancount++;
    if(mancount==) P(mutex);
    V(mutex_man);
    洗澡；
    P(mutex_man);
    mancount—;
    if(mancount==) V(mutex);
    V(mutex_man)
}

南大18年真题过桥问题：汽车只能单向过桥，最多12辆车同时过桥。

• 理发师问题

引入一个计数器waiting记录等待理发的顾客坐的椅子数，初值为0最大为N。mutex是用于对计数器waiting操作的互斥信号量

引入信号量customers记录等候理发的顾客数，并用于阻塞理发师进程，初值为0

引入信号量barbers记录正在等候顾客的理发师数，并用于阻塞顾客进程，初值为0

想法：其实和N生产者1消费者N缓冲区的生产者消费者问题有些类似，但是多了P(barbers)和V(barbers)；此外，椅子数改用了int数waiting再用信号量mutex进行互斥。

int waiting = ;
Semaphore customers = ;
Semaphore barbers = ;
Semaphore mutex = ；
cobegin
process barbers() {
    while(true) {
       P(customers);//判断是否有顾客，没有的话理发师睡眠
       P(mutex);
        waiting--;
        V(barbers);//理发师准备为顾客理发
        V(mutex);
        cuthair();  //理发师理发，不应放在临界区
    }
}
process customer_i() {
    P(mutex);
    if(waiting<N) {
        waiting++;
        V(customers);//唤醒理发师
        V(mutex);
        P(barbers);//如果理发师忙则等待
        get_haircut();
    }
    else V(mutex);//人满了，顾客离开
}
coend