进程同步

生产者消费问题

# 信号量
semaphore full=0,empty=n;
semaphore mutex = 1;
item buf[n];
int in=0,out=0;
produce(){
whiel(1){
 wait(empty);
 wait(mutex);
 buf[in]=nextp;
 in=(in+1)%n;
 signal(mutex);
 signal(full);
}
}
consumer(){
    while(1){
    wait(full);
    wait(mutex);
    nextc=buf[out];
    out=(out+1)%n;
    signal(mutex);
    signal(empty)
    }
}

#And信号
semaphore full=0,empty=n;
semaphore mutex = 1;
item buf[n];
int in=0,out=0;
produce(){
whiel(1){
 Swait(empty,mutex);
 buf[in]=nextp;
 in=(in+1)%n;
 Ssignal(mutex,full);
}
}
consumer(){
    while(1){
    Swait(empty,mutex);
    nextc=buf[out];
    out=(out+1)%n;
    Ssignal(empty,mutex);
    }
}


#管程 注意多了个count 变量 少了mutex变量(其实是因为管程只允许一个进程执行 ）
Monitor producerconsumer{
    item buf[n];
    int in,out;
    conditon notfull,notnull;
    int count;
    public:
        void put(item x){
            if(count >= N)cwait(notfull);
            buf[in]=item；
            in=(in+1)%n;
            ccount++;
            csignal(notempty);
        }
        void get(item x){
            if(count<=0)cwait(notempty);
            x = buf[out];
            out = (out+1)%n;
            count --;
            csignal(notfull);
        }
        #初始化语句
        {
            in=0;out =0 ;count =0
        }
}PC;
    void{
        producer(){
            item x;
            while(true){
                PC.put(x);
            }
        }
    void consumer(){
        item x;
        while(true){
            PC.get(x);
        }
    void main(){
        prducer();
        consumer();
    }
    }


#较为复杂的生产者消费问题
#爸爸放苹果 妈妈放橘子 女儿吃苹果 儿子吃橘子 只有一个盘子
semaphore apple=0,orange=0;mutex=1;
dad{
while(1){
    prepare apple;
    p(mutex)
    put;
    signal(mutex);
    signal（apple);
}
}
daughter{
    while(1){
    p(apple);
    p(mutex);
    getapple;
    signal(mutex);
    eatapple
    }
}

读者写者问题

semaphore wmutex=1,rmutex=1;//注意者个rmutex 是针对count变量的
int count = 0;//这的数量是指读进程的数量
read(){
while(1){
    wait(rmutex);
    if(count == 0){
        wait(wmutex);
    }
    
    count ++;
    signal(rmutex);//注意这个语句放在判断后面
    read;
    wait(rmutex);
    count --;
    
    if(count ==0){
        signal(wmutex);
    }
    signal(rmutex); //注意这个语句放在判断后面
}
}
consumer(){
while(1){
    wait(wmutex);
    write;
    signal(wmutex);
}
}


#限制读者数量的读者写者问题
semaphore mutex=1,count=n;
read(){
    do{
    swait(count,1,1);
    swait(mutex,1,0);
    read;
    signal(count,1);
}while(1);
}
write(){
    do{
        swait(mutex,1,1,count n,0);  //注意这必须用信号集
        write;
        signal(mutex,1)
    }while(1)
}





#写者优先 这里的优先是指相对而言的 即写和读具有相同的优先级
semaphore wmutex=1,rmutex=1，mutex = 1;//注意者个rmutex 是针对count变量的  注意这个mutex是为了实现公平访问
int count = 0;//这的数量是指读进程的数量
read(){
    wait(mutex)
    while(1){
    wait(rmutex);
    if(count == 0){
        wait(wmutex);
    }
    
    count ++;
    signal(rmutex);//注意这个语句放在判断后面
    read;
    signal(mutex);//mutex 放这还是可以做到多进程读
    wait(rmutex);
    count --;
    
    if(count ==0){
        signal(wmutex);
    }
    signal(rmutex); //注意这个语句放在判断后面

    }
}
write(){
    while(1){
    wait(mutex);
    wait(wmutex);
    write;
    signal(wmutex); 
    signal(mutex);
    
    }
}

吸烟者问题

int random;
semaphore offer1=0,offer2=0,finish=1;
provide(){
    while(1){
        p(finish);
        random= new random()%2;
        if(random==0)signal(offer1);
        else signal(offer2);
    }
}
p1(){
    while(1)[
        p(offer1);
        
        v(finish);
    }
}
p2(){
    while(1){
        p(offer2);
                
        v(finish);
    }
}

哲学家进餐问题

semaphore chopstick[5]={1,1,1,1,1};
pi(){
    do{
        swait(chopstick[i],chopstick[i+1]%5);
        eat;
        signal(chopstick[i],chopstick[i+1]%5);
        think;
    }while(1);
}
    

转载于:https://www.cnblogs.com/0x636a/p/11305868.html