操作系统-PV习题

（1）阅览室问题：加入阅览室入口有一本登记册，每个人都必须按顺序签名进去。

想法：登记册可以用结构数组A[]表示，包含name和number。此外，还需要信号量seatcount表示剩余座位数。

使用信号量mutex约束每次只有一个人能修改登记册

struct { 
    char name[10]; 
    int number;
}A[100];
semaphore mutex = 1; //控制A[]被修改的信号量
semaphore seatcount = 100; //剩余的座位数
int i;
for(i=0; i<100; i++) {
    A[i].number=i;
    A[i].nume=null;
}
cobegin
process readeri(char readername[]) {
    P(seatcount);
    P(mutex);
    for(int i=0; i<100; i++) {
        if(A[i].name==null) A[i].name=readername;
        reader get the seat number i;
    }
    V(mutex);
    {进入阅览室座位号i，坐下读书}；
    P(mutex);
    A[i].name = null;
    V(mutex);
    V(seatcount);
}
coend

（2）四个进程Pi（i=0…3）和四个信箱Mj（j=0…3），进程间借助相邻信箱传递消息，即Pi每次从Mi中取一条消息，经加工后送入M(i+1)mod4，其中M0、M1、M2、M3分别可存放3、3、2、2个消息。初始状态下，M0装了三条消息，其余为空。试以P、V操作为工具，写出Pi（i=0…3）的同步工作算法。

想法：说穿了还是有缓冲区的生产者消费者问题，每个信箱需要用信号量empty表示剩余空间、full表示剩余信件。此外还需要int数in、out指明信箱中存取信的位置，以及对应信号量mutex。

semaphore mutex1 = mutex2 = mutex3 = mutex0 = 1; //约束每个信箱同一时间只能有一个进程操作
semaphore empty0 = 0 , empty1 = 3 , empty2 = empty3 =2; //信箱剩余空间
semaphore full0 = 3 , full1 = full2 = full3 =0; //信箱剩余信件数
int in0 = in1 = in2 = in3 = out0 = out1 = out2 = out3 =0; //信箱中存、取信的位置，初始均为0
cobegin
process P0( ) {
    while(true) {
        P(full0);
        P(mutex0);
        {从M0[out0]取一条消息};
        out0 = ( out0 + 1 ) % 3;
        V(mutex0);
        V(empty0);
        {加工消息};
        P(empty1);
        P(mutex1);
        {消息存M1[in1]};
        in1 = ( in1 + 1 ) % 3;
        V(mutex1);
        V(full1);
    }
}
/*P1-P3略*/
coend    

（3）今有k个进程，它们的标号依次为1~k，如果允许它们同时读文件file，但必须满足条件：参加同时读文件的进程的标号之和需小于M（k<M）

想法：用一个数numbersum记录当前读文件的进程标号之和，通过信号量mutex实现对其的互斥操作

如果进程发现自己不能运行，就要P(waits)把自己阻塞，阻塞后因为其还在numbersum的临界区内，因此其它进程也进不来了；每当读文件完成，释放一个等待的进程；被释放的进程再次检测自己能否运行，不能的话继续P(waits)把自己阻塞

semaphore waits = 0;
Semaphore mutex = 1;
int numbersum = 0;
cobegin
process readeri(int number) {    
    P(mutex);
    while(numbersum+number>=M) {
        V(mutex);
        P(waits);
    }
    numbersum = numbersum + number；
    V(mutex)；
    Read file；
    P(mutex)；
    numbersum = numbersum - number；
    V(waits)； 
    V(mutex);
}
coend

（5）轮流捡黑、白棋子：其实就是最简单的生产者消费者问题

semaphore s1 = 1; //可捡白子
semaphore s2 = 0; //可捡黑子
process p1() {
    while(true) {
        P(s1);
        捡白子；
        V(s2);
    }
}
process p2() {
    while(true) {
        P(s2);
        捡白子；
        V(s1);
    }
}

南大13年真题：A捡黑子并计数，B捡白子并计数。不要求轮流捡，但要求互斥捡。C等待AB完成后，合计计数。

想法：通过互斥信号量mutex实现A和B互斥捡棋子。计数器则不需要互斥，因为黑子、白子是分两个计数器；A和B计数完成后各自V(allow)，从而允许C工作

Semaphore allow = -1;
Semaphore mutex = 1;
int count = count_black = count_black = 0;
process A(){
    while(true){
        P(mutex);
        get(black)；
        V(mutex);
        if(取到了){count_black++;}
        else break;
    }
    V(allow);
} 
process B(){
    while(true){
        P(mutex);
        get(write)；
        V(mutex);
        if(取到了){count_write++;}
        else break;
    }
    V(allow);
}
process C(){
    P(allow);
    count = count_black + count_write;
    printf();
}

（6）n1个进程通过m个缓冲区向n2个缓冲区发消息，每条消息n2个接收进程都要各自接收一次。

思路：课本答案的做法是把这一组缓冲区看成n2组缓冲区（每组m个），每个发送进程需要同时写n2个缓冲区。但是我觉得答案做法很迷啊，m个缓冲区直接被它强行变成了n2*m个缓冲区，每次写一个、接收n2次，变成了每次写n2个、接收n2次。而且答案明明把缓冲区分为n2组，但是只有一个信号量mutex实现对缓冲区操作的互斥。

semaphore mutex , empty[n2] , full[n2];
int i;
mutex = 1;
for(i=1; i<n2; i++) {
    empty[i]=m;
    full[i]=0;
}
cobegin
send() {           
    for(int i=0;i<n2;i++) {
        P(empty[i]);
        P(mutex);
        {将消息放入缓冲区;}
        V(mutex);
    }
    for(int i=0;i<n2;i++){
        V(full[i]);
    }
}
receive() {       
    for(int i=0;i<n2;i++) {
        P(full[i]);
        P(mutex);
        {从缓冲区中取出信息;}
        V(mutex);
    }
    for(int i=0;i<n2;i++) {
        V(empty[i]);
    }
}
coend

（7）生产者进程每次写3个缓冲区，消费者进程每次读一个缓冲区

思路：答案的思路是通过信号量s1控制每次只允许一个生产者写，通过信号量s2控制每次只允许一个消费者读。因此本题生产者和消费者可以同时工作。

定义了一个初始为0的int数count，每次消费都将其加1，每三次消费之后count达到3，才V(sput)一次，允许一次生产；每次生产之后进行三次V(sget)允许三次消费。

int buf[9];
int count = getptr = putptr = 0;
semaphore s1 = s2 = 1;
Semaphore sput = 1;
Semaphore sget = 0;
cobegin
process producer_i() {
    while(true) {
        P(sput);
        P(s1);
        buf[putptr] = 1;
        putptr = ( putptr + 1 ) % 9;
        buf[putptr] = 2;
        putptr = ( putptr + 1 ) % 9;
        buf[putptr] = 3;
        putptr = ( putptr + 1 ) % 9;
       V(sget);
        V(sget);
        V(sget);
        V(s1);        
    }
}
process consumer_j() {
    int y;
    while(true) {
       P(sget);
        P(s2);
        y = buf[getptr];
        getptr = ( getptr + 1 ) % 9;
        count++;
        if(count==3){
            count = 0;
           V(sput);
        }
        V(s2);
        消费整数y;
    }
}
coend

（8）有三组工人和N个槽，第一组工人生产车架，第二组工人生产车轮，第三组工人用车架和四个车轮生产一辆车

思路：其实就是上一题的生产者消费者问题的加强版，可以把N个槽分为N/5、4N/5两部分，分别装车架和车轮，否则可能会出现装满车架或车轮的情况。

通过信号量mutex1控制每次只有一个进程操作第一个槽（即只有1个生产者放车架或1个消费者拿车架）；通过mutex2控制每次只有一个进程操作第二个槽（即只有一个生产者放车轮或1个消费者拿车轮）。

每生产一个车架就可以直接拿（不需要像车轮那样通过计数器count控制），因此每次生产一个车架都V(s3)一次。

每生产四个车轮才能拿一次，因此定义了一个初始为0的int数count，每次生产车轮都将其加1，count达到4时才V(s4)一次。因为有mutex2的存在，因此每次只有一个进程能修改count。

semaphore mutex1 = mutex2 = 1;
semaphore s1 = N/5 , s2 = 4N/5 , s3 = s4 = 0;
int count = 0;
int in1 = in2 = out1 = out2 = 0;
cobegin
process worker1() {
    while(true) {
        加工一个车架；
        P(s1);
        P(mutex1);
        车架放入box[in1];
        in1 = (in1 +1) % (N/5);
        V(mutex1);
        V(s3);
}
process worker2() {
    while(true) {
        加工一个车轮；
        P(s2);
        P(mutex2);
        车架放入box[in2];
        in2 = (in2 +1) % (4N/5);
        count = count + 1;
        if(count==4) {
            count = 0;
            V(s4);
        }
        V(mutex2);
}
process worker3() {
    while(true) {
        P(s3);
        P(mutex1);
        从box[out1]拿车架；
        out1 = (out1 + 1) % (N/5);
        V(mutex1);
        V(s1);
        P(s4);
        P(mutex2);
        从box[out2]开始取四个车轮；
        out2 = (out2 + 4) % (4N/5);
        V(s2);
        V(mutex2);
        装配车子；
    }
}
ceend

（9）有一个仓库，可存放X、Y两种产品，仓库的存储空间足够大，但要求：(1) 每次只能存入一种产品X或Y， (2) 满足-N<X-Y<M

想法：可以设置两个信号量来控制X、Y产品的存放数量关系：

sx表示当前允许X产品比Y产品多入库的数量，即在当前库存量和Y产品不入库的情况下，还可以允许sx个X产品入库，初始时，若不放Y而仅放X产品，则sx最多为M－1个；

sy表示当前允许Y产品比X产品多入库的数量，即在当前库存量和X产品不入库的情况下，还可以允许sy个Y产品入库，初始时，若不放X而仅放Y产品，则sy最多为N－1个。

当往库中存放入一个X产品时，则允许存入Y产品的数量也增加1，故信号量sy应加1；当往库中存放入一个Y产品时，则允许存入X产品的数量也增加1，故信号量sx应加1。

semaphore mutex=1;         
semaphore sx = M-1;
semaphore sy = N-1;
cobegin
process storeX( ) {
    while(true) {
        P(sx);
        P(mutex);
       {将X产品入库}；
       V(mutex);
        V(sy);
    }
}
process storeY( ) { 
    while(true) {
       P(sy);
       P(mutex);
       {将Y产品入库}；
       V(mutex);
       V(sx);
    }
}
coend

（10）有一个仓库，可放入A、B两种产品，最大库容量各为m个，生产车间不断地取A、B进行装配，每次各取一个。为了零件腐蚀，必须按照先入库者先出库的顺序。有两组供应商分别不断地供应A和B，每次一个。为了保证配套和库存合理，当某种零件比另一种超过n个时，暂停对数量大的零件的进货。

想法：这题实际是上一题的强化版，按照题意一共四种约束关系：0≤A≤m、0≤B≤m、B-A≤n、A-B≤n，分别通过信号量empty1、full1、empty2、full2、sa、sb进行控制。

答案是通过mutex约束每次只有一个进程操作仓库。其实也可以把约束条件放得更宽泛些。

semaphore empty1 , empty2 , full1 , full2 , mutex , sa , sb;
int in1 , in2 , out1 , out2;
empty1 = empty2 = m; //剩余可放空间
full1 = full2 = 0; //剩余产品数
sa = sb = n;
mutex = 1;
in1 = in2 = out1 = out2 = 0;
cobegin
process put_A() {
    while(true) {
        P(empty1);
        P(sa);
        P(mutex);
        把A零件放入buffA[in1]；
        in1 = (in1 + 1) % m；
        V(mutex);
        V(sb);
        V(full1);
    }
} 
process put_B() {
    while(true) {
        P(empty2);
        P(sb);
        P(mutex);
        把B零件放入buffB[in2]；
        in2 = (in2 + 1) % m；
        V(mutex);
        V(sa);
        V(full2);
    }
} 
process get() {
    while(true) {
        P(full1);
        P(full2);
        P(mutex);
        从buffA[out1]取A零件;
        从buffB[out2]取B零件;
        out1 = (out1 + 1) % m；
        out2 = (out2 + 1) % m；
        V(mutex);
        V(empty1);
        V(empty2);
        把A和B装配成产品;       
    }
}
coend

因为装配时A和B各取一件，所以对它们的相对关系并无影响，因为无需对信号量sa和sb进行修改。

答案用了信号量mutex约束三个进程不能同时工作，其实我觉得应该改用三个信号量。

（11）能容纳500人的博物馆，每次只能一个人进出

思路：使用mutex约束每次只有一个人使用门。本题必须注意，进门与出门操作必须在P(empty)和V(empty)之间的临界区内，即有空位才能进门，出门后才释放空位

Semaphore empty = 500;
Semaphore mutex = 1;
cobegin
process_i(){
    P(empty);
    P(mutex);
    进门；
    V(mutex);
    参观；
    P(mutex);
    出门；
    V(mutex);
   V(empty);
}

（12）三个线程增加互斥条件

typedef struct{
    float a;
    float b;
}cnum;
cnum x , y ,z;
cnum add(cnum p ,cnum q){
    cnum s;
    s.a = p.a + q.a;
    s.b = s.b + q.b;
    return s;
}

想法：本题先看代码，thread1和thread2会修改w，但是w是它们自身创建的，其它线程也没有使用到；而thread3则修改了z、y；

thread3会修改z，而thread2会访问z，必须定义信号量使它们互斥访问z；

thread3会修改y，而thread1和thread2都会访问y，因此需要定义互斥信号量mutex_y1使thread1和thread3对y互斥访问、定义互斥信号量mutex_y2使thread2和thread3对y互斥访问（thread2和thread3不需要互斥y）

Semaphore mutex_y1 = 1;  //线程1、3对y的互斥访问
Semaphore mutex_y2 = 1;  //线程2、3对y的互斥访问
Semaphore mutex_z = 1;   //线程2、3对z的互斥访问
 
thread1{
    cnum w;
    P(mutex_y1);
    w = add(x , y);
    V(mutex_y1);
}    
thread2{
    cnum w;
    P(mutex_y2);
    P(mutex_z);
    w = add(y , z);
    V(mutex_z);
    V(mutex_y2);
}    
thread3{
    cnum w;
    w.a = 1;
    w.b = 1;
    P(mutex_z);
    z = add(z , w);
    V(mutex_z);
    P(mutex_y1);
    P(mutex_y2)
    y = add(y , z);
    V(mutex_y1);
    V(mutex_y2);
}    

（13）14年南大真题：缓冲区可放2000字节，P进程读入数据到缓冲区，Q1、Q2从缓冲区取数据并计算加工，并把结果打印出来。

题目给的子程序：read20()从输入设备读20个字数据到缓冲区；

                             get20()从缓冲区取20字节；

                             comp40t30()计算加工40个字得到结果30字节；

                             print15()打印15字节

Semaphore mutex = 1;
Sempahore full = 1;
Semaphore empty = 100;
process P(){
    P(empty);
    P(mutex);
    read20();
    V(mutex);
    V(full);
}
Process Q1(){
    P(full); get20();
    P(full); get20();
    comp40t30();
    V(empty); print15;
    V(empty); print15;
}