pv操作经典题目分析

pv操作题目分析步骤***

1. 关系分析。找出题目中描述的各个进程，分析他们之间的同步互斥关系
2. 整理思路。根据各进程的操作流程确定p、v操作的大致顺序
3. 设置信号量。设置需要的信号量，并根据题目条件确定信号量初值。

生产者消费者问题

semaphore mutex = 1;//对缓冲区互斥
semaphore empty = n;//对空闲缓冲区数量的同步
semaphore full = 0;//对产品数量的同步
producer(){
  while(1){
    生产一个产品;
    p(empty);
    p(mutex);
    把产品放入缓冲区；
    v(mutex);
    v(full);
}}
consumer(){
    while(1){
        p(full);
        p(mutex);
        从缓冲区取走一个产品;
        v(mutex);
        v(empty);
        使用产品;
    }
}

实现互斥的p操作一定要在实现同步的p操作之后，，否则会导致死锁，两个v操作的顺序可以交换

多生产者多消费者问题

semaphore mutex = 1;//实现互斥访问盆子（缓冲区）
semaphore apple = 0;//盘子中有几个苹果
semaphore orange = 0;//盘子中有几个橘子
semaphore plate = 1;//盘子中还可以放多少个水果
dad(){
    while(1){
        p(plate);
        p(mutex);
        苹果放入盘子；
        v(mutex);
        v(apple);
    }
}
mom(){
    while(1){
        p(plate);
        p(mutex);
        橘子放入盘子；
        v(mutex);
        v(orange);
    }
}
daughter(){
    while(1){
        p(apple);
        p(mutex);
        苹果取出盘子；
        v(mutex);
        v(plate);
    }
}
son(){
    while(1){
        p(orange);
        p(mutex);
        苹果放入盘子；
        v(mutex);
        v(plate);
    }
}

本题中的缓冲区大小为1，在任何时刻，apple，orange，plate三个同步信号量中最对只有一个是1，因此在任何时刻，最多只有一个进程的p操作不会被阻塞，并顺利进入临界区。因此，不设置专门的互斥信号量mutex。也不会出现多个进程同时访问盘子。

吸烟者问题

一生产者多消费者

seamphore offer1 = 0;//桌上组合一的数量
seamphore offer2 = 0;//桌上组合二的数量
seamphore offer3 = 0;//桌上组合三的数量
seamphore finish = 0;//抽烟是否完成
int i = 0;//用于实现“三个抽烟者轮流抽烟”
provider(){
    while(1){
        if(i==0){
            将组合一放桌上;
            v(offer1);
        }else if(i==2){
            将组合二放桌上;
            V(offer2);
        }else if(i==2){
            将组合三放桌上;
            v(offer3);
        }
        i = (i+1)%3;
        p(finish);
    }
}
smoker1(){
    while(1){
        p(offer1);
        从桌上拿走组合1；
        抽掉;
        v(finish);
    }
}
smoker2(){
    while(1){
        p(offer2);
        从桌上拿走组合2；
        抽掉;
        v(finish);
    }
}smoker1(){
    while(1){
        p(offer3);
        从桌上拿走组合3；
        抽掉;
        v(finish);
    }
}

是够需要设置专门的互斥信号量？缓冲区大小为1，同一时刻，四个信号量中至多有一个的值为一。

读者写者问题

核心思想在于设置一个计算器count用来记录当前正在访问共享文件的读进程数

semaphore rw = 1;//实现对文件的互斥访问。表示当前是否有进程在访问共享文件
int count = 0;//记录当前有几个读进程在访问文件
semaphore mutex = 1;//保证对count变量的互斥访问
writer(){
    while(1){
        p(rw);
        写文件、
        v(rw);
    }
}
reader(){
    while(1){
        p(mutex);
        if(count == 0)
            p(rw);
        count++;
        v(mutex);
        读文件、
        p(mutex);
        count--;
        if(count==0)
            v(rw);
        v(mutex);
    }
}

若有源源不断的读进程，则会导致写进程饥饿，因此读进程是优先的，设置信号量semaphore w =1,用于实现“写优先”。

semaphore rw = 1;//实现对文件的互斥访问。表示当前是否有进程在访问共享文件
int count = 0;//记录当前有几个读进程在访问文件
semaphore mutex = 1;//保证对count变量的互斥访问
semaphore w = 1;//用于实现“写优先”
writer(){
    while(1){
        p(w);
        p(rw);
        写文件、
        v(rw);
        v(w);
    }
}
reader(){
    while(1){
        p(w);
        p(mutex);
        if(count == 0)
            p(rw);
        count++;
        v(mutex);
        v(w);
        读文件、
        p(mutex);
        count--;
        if(count==0)
            v(rw);
        v(mutex);
    }
}

哲学家就餐问题

每个哲学家进程需要同时持有两个临界资源,因此就有“死锁”问题的隐患

semaphore chopstick[5] = {1,1,1,1,1};
semaphore mutex;//互斥取筷子
pi(){//i号哲学家的进程
    while{
        p(mutex);
        p(chopstick[i]);//拿左边筷子
        p(chopstick[(i+1)%5]);//拿右边筷子
        v(mutex);
        吃饭...
        v(chopstick[i]);
        v(chopstick[(i+1)%5]);
    }
}