操作系统之经典同步问题（司机售票员、文件打印、多个生产者消费者、放水果吃水果、读者优先、写者优先、哲学家死锁问题）

博客主页：真的睡不醒

系列专栏：深度学习环境搭建、环境配置问题解决、自然语言处理、语音信号处理、项目开发

每日语录：闲看花开，静待花落，冷暖自知，干净如始。

感谢大家点赞收藏⭐指正✍️

目录

一、司机与售票员进程同步问题

二、PA、PB、PC合作解决文件打印问题

三、多个生产者和多个消费者问题

四、放水果吃水果问题

五、读者写者问题

六、哲学家吃饭问题

---

一、司机与售票员进程同步问题

问题描述：在公共汽车上，司机和售票员的工作流程如图所示。为保证乘客的安全，司机和售票员应密切配合协调工作。请用信号量来实现司机与售票员之间的同步。

问题分析：

        1、在该问题中，司机和售票员不存在资源的争夺

        2、司机和售票员为同步关系

        3、司机启动车辆前需要收到已经关门的信号

        4、售票员开车门前需要收到车已经到站的信号

所以需要设置关门信号量door=0，停车信号量stop=0。

具体代码如下：

Semaphore door=0;
Semaphore stop=0;
Void driver(){
    while(1){
        wait(door);     // 等待关门信号
        启动车辆;
        正常行车;
        到站停车;        
        signal(stop);    // 停车信号
    }
}

Void conductor(){
    while(1){
        关车门;
        signal(door);    // 关门信号
        售票;
        wait(stop);      // 等待停车信号
        开车门;
    }
}

二、PA、PB、PC合作解决文件打印问题

问题描述：有三个进程PA、PB和PC协作解决文件打印问题。PA将文件记录从磁盘读入内存的缓冲区1，每执行一次读一个记录；PB将缓冲区1的内容复制到缓冲区2中，每执行一次复制一个记录：PC将缓冲区2的内容打印出来，每执行一次打印一个记录。缓冲区的大小与记录大小一样。请用信号量来保证文件的正确打印。

问题分析：

        1、有两个临界资源，分别是缓冲区1和缓冲区2

        2、PA和PB互斥访问缓冲区1

        3、PB和PC互斥访问缓冲区2

        4、PA将文件记录从磁盘读入缓冲区1后，如果PB没有拿走这个记录，那么PA则不能再

             执行读入操作，PB和PC也是如此。

所以需要设置四个互斥信号量：

        1、empty1、empty2，分别代表缓冲区1和缓冲区2是否为空，初值为1，代表空。

        2、full1、full2，分别代表缓冲区1和缓冲区2是否有文件记录，初值为0，代表没有。

代码如下：

Semaphore emptyA = 1;
Semaphore emptyB = 1;
Semaphore fullA = 0;
Semaphore fullB = 0;
PA(){
	while(1){
		读取磁盘一个记录; 
		wait(emptyA);	// 缓冲区1是否为空 
		将记录存入缓冲区1;
		signal(fullA); 	// 将缓冲区1标记为有数据 
	}
}

PB(){
	while(1){
		wait(fullA);	
		读出缓冲区1的记录;
		signal(emptyA);	// 将缓冲区1标记为空 
		wait(emptyB);	// 缓冲区2是否空 
		将记录存入缓冲区2;
		signal(fullB); 	// 缓冲区2有数据 
	}
}
PC(){
	while(1){
		wait(fullB);	// 缓冲区2是否有数据 
		读出缓冲区2的记录;
		signal(emptyB);  // 将缓冲区2标记为空 
		打印; 
	}
}

main(){
	cobegin();
	PA();
	PB();
	PC();
	coend();
}

三、多个生产者和多个消费者问题

系统中有多个生产者进程和多个消费者进程，共享一个能存放1000件产品的环形缓冲区（初始为空），当缓冲区未满时，生产者进程可以放入其生产的一件产品，否则等待；当缓冲区未空时，消费者进程可以从缓冲区取走一件产品，否则等待。要求一个消费者进程从缓冲区连续取出10件产品后，其他消费者进程才可以取产品。请使用信号量P,V（wait（），signal（））操作实现进程间的互斥与同步，要求写出完整的过程，并说明所用信号量的含义和初值。

问题分析：

        1、典型的生产者消费者问题，只需要在模型上加上一个信号量，来保证一个消费者能

             够连续取10件产品。

        2、设置四个变量mutex1，mutex2，empty，full。

             mutex1控制一个消费者进程在一个周期内（10次）对缓冲区的访问；

             mutex2控制生产者和消费者互斥对缓冲区的访问；

             empty表缓冲区空位数，初值1000；

             full表缓冲区产品数。

代码如下：

Semaphore mutex1 = 1;
Semaphore mutex2 = 1;
Semaphore empty = 1000;
Semaphore full = 0;
producer(){
	while(1){
		生产一个产品;
		P(empty); // 缓冲区是否还有空位
		P(mutex2);  // 互斥访问缓冲区
		将产品放入缓冲区;
		V(mutex2);
		V(full); 
	}
} 
consumer(){
	while(1){
		P(mutex1) // 连续拿走10次
		for(int i=0; i<10; i++){
			P(full);
			P(mutex2); // 互斥访问
			取走一个产品;
			V(mutex2); 
			V(empty);	// 缓冲区空间+1	
		} 
	}
}

四、放水果吃水果问题

问题描述：桌子上有一只盘子，每次只能向其中放一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专等吃盘子中的橘子，女儿专等吃盘子中的苹果。只有盘子为空时，爸爸或妈妈就可向盘子中放一个水果；仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出。请使用信号量P,V（wait（），signal（））操作实现进程间的互斥与同步，要求写出完整的过程，并说明所用信号量的含义和初值。

问题分析：

        1、由每次只能放一个水果可知，爸爸和妈妈是互斥关系

        2、爸爸和女儿、妈妈和儿子是同步关系，且这两对进程必须连起来

        3、儿子和女儿之间没有同步互斥关系，不能并发执行

代码如下：

Semaphore plate = 1; 
Semaphore orange = 0;
Semaphore apple = 0;
father(){
	while(1){
		P(plate);
		放苹果;
		V(apple); // 可以吃苹果 
	}
}
mother(){
	while(1){
		P(plate);
		放橘子;
		V(orange);  // 可以吃橘子 
	}
}
daughter(){
	while(1){
		P(apple);
		吃苹果;
		V(plate); // 可以放水果 
	}
} 
son(){
	while(1){
		P(orange);
		吃橘子;
		V(plate); // 可以放水果 
	}
} 

五、读者写者问题

读者优先

问题分析：

        1、写者在进行写操作之前，应让已有的读者和写者全部退出；

        2、写者的写操作未完成前，不允许其他读者和写者进行操作；

        3、可以多个读者同时进行读操作；

        4、只允许一个写者进行写操作；

        关键：读者必须实现和写者互斥的同时和其他读者同步。

       

信号量设置：

        1、count 用来记录当前读者的人数，同时需要用mutex来实现对count的互斥访问，

             count 初值为0，mutex初值为1；

        2、同时需要设置 rw 来实现读者写者对文件的互斥访问。

代码如下：

Semaphore rw=1;
Semaphore  mutex=1;
Semaphore  count=0;
writer(){
    while(1){
        P(rw);
        write;
        V(rw);
    }
}
reader(){
    while(1){
        P(mutex);
        if(count == 0){
            P(rw);
        }
        count++;
        V(mutex);
        read;
        p(mutex);
        count--;
        if(count == 0){
            V(rw);
        V(mutex);
        }
    }
}

写者优先

问题描述：经典的读者-写者问题通常采用读者优先原则实现读者和写者进程之间对文件的互斥访问，这样会导致写者处于较长时间的“饥饿”状态，请采用写者优先原则实现，即当读者和写者进程并发访问文件时能按照读者和写者先来先访问的原则运行。

问题分析：

        1、读进程在读共享文件时，如果有写进程的访问，则应禁止后续读者访问进程的请

             求，等到当前读者阅读完毕，立刻让写进程执行，只有无写进程执行时，才允许

             读进程继续执行；

        2、要想实现写者优先，只需要在原代码的基础上，读者和写者再加一个互斥变量w，

             来实现写者优先；

        3、写者在进行写之前需要确保当前没有写者在写文件，并且没有读者在读文件。

信号量设置：

        1、互斥变量w，实现写者优先；

        2、count 用来记录当前读者的数量；

        3、mutex用来实现对count的互斥访问；

        4、rw用来实现读者写者对文件的互斥访问。

Semaphore rw=1;
Semaphore mutex=1;
Semaphore count=0;
Semaphore W=1;
writer(){
    while(1){
        P(W);
        P(rw);
        write;
        V(rw);
        v(W);
    }
}
reader(){
    while(1){
        P(W);
        P(mutex);
        if(count == 0){
            P(rw);
        }
        count++;
        V(mutex);
        V(W);
        read;
        p(mutex);
        count--;
        if(count == 0){
            V(rw);
        V(mutex);
        }
    }
}

六、哲学家吃饭问题

试用记录型信号量写出一个不会死锁的哲学家进餐问题的算法。

问题分析：为防止死锁发生，可以增加一些限制条件。

如当一名哲学家左右两边的筷子都可用，时才允许他抓筷子。

信号量设置：

        1、chopsticks[5] = {1, 1, 1, 1, 1};

        2、mutex = 1，确保左右都有筷子；

代码如下：

Semaphore chopsticks[5] = {1, 1, 1, 1, 1};
Semaphore mutex = 1;
P(){
    do{
        P(mutex);
        P(chopsticks[i]);
        P(chopsticks[(i+1)%5]);
        V(mutex);
        吃饭;
        V(chopsticks[i]);
        V(chopsticks[(i+1)%5]);
        思考;
        }while(1)
}