【操作系统】应用题：进程通信（PV操作）

原创于 2024-12-05 19:59:14 发布 · 1.6k 阅读

35 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

笔记

操作系统

【操作系统】应用题：进程通信（PV操作）

第一题
第二题
第三题
第四题
第五题
第六题
第七题

第一题

（1）有三个并发进程R、W1和W2，共享两个各可存放一个数的缓冲区B1、B2。进程R每次从输入设备读入一个数，若读入的是奇数，则将它存入B1中，若读入的是偶数，将它存入B2中；当B1中有数，由进程W1将其打印输出；当B2中有数，进程W2将其打印输出。试编写保证三者正确工作的程序。

关系分析（个人想法，仅供参考）：

R每次读一个数a，若为奇数放入B1，若为偶数放入B2
W1只当B1有数时才输出
W2只当B2有数时才输出

struct semaphore B1Emp = 1, B2Emp = 1, B1Full = 0, B2Full = 0;
void R(){
	while(1){
		获取一个数a;
		if(a是奇数){
			P(B1Emp);
			把a放入B1;
			V(B1Full);	
		}else{
			P(B2Emp);
			把a放入B2;
			V(B2Full);	
		}
	}
}
void W1(){
	while(1){
		P(B1Full);
		从B1中读取a并打印;
		V(B1Emp);	
	}
}
void W2(){
	while(1){
		P(B2Full);
		从B2中读取a并打印;
		V(B2Emp);	
	}
}
void main(){
	cobegin
		R();W1();W2();
	coend
}

第二题

（2）8个协作的任务A、B、C、D、E、F、G、H分别完成各自的工作。它们满足下列条件：任务A必须领先于任务B、C和E；任务E和D必须领先于任务F；任务B和C必须领先与任务D；而任务F必须领先于任务G和H。试写出并发程序，使得在任何情况下它们均能正确工作。

struct semaphore s1=0,s2=0,s3=0,s4=0;
void A(){
	while(1){
		V(s1);
	}
}
void B(){
	while(1){
		P(s1);
		V(s2);
	}
}
void C(){
	while(1){
		P(s1);
		V(s2);
	}
}
void D(){
	while(1){
		P(s2);
		V(s3);
	}
}
void E(){
	while(1){
		P(s1);
		V(s3);
	}
}
void F(){
	while(1){
		P(s3);
		V(s4);
	}
}
void G(){
	while(1){
		P(s4);
	}
}
void H(){
	while(1){
		P(s4);
	}
}
void main(){
	cobegin
		A();B();C();D();E();F();G();H();
	coend
}

第三题

（3）多个进程共享一个文件，其中只读文件的称为读者，只写文件的称为写者。读者可以同时读，但写者只能独立写。问：

说明进程间的制约关系，应设置哪些信号量？
```
读优先时，设置信号量 read=1,write=1
```

用wait、signal操作写出其同步程序。

struct semaphore read=1,write=1;
int read_count = 0;

void reader(){
	while(1){
		P(read);						// 读进程间对read_count的互斥访问
		if (read_count==0) P(write);	// 第一个读进程锁住write
		read_count++;
		V(read);
		读操作;
		P(read);
		read_connt--;
		if (read_count==0) V(write);	// 最后一个读进程解锁write
		V(read);
	}
}
void writer(){
	while(1){
		P(write);
		写操作;
		V(write);	
	}
}
void main(){
	cobegin
		reader();writer();
	coend
}

修改上述算法，使得它对写者优先，即一旦有写者到达，后续的读者必须等待。而无论是否有读者在读文件。

struct semaphore read=0,write=0,read_mutex=1,write_mutex=1;
int read_count=0, write_count=0;
void read(){
	while(1){
		P(write);
		P(read_mutex);
		if (read_count==0) P(read);
		read_count++;
		V(read_mutex);
		V(write);
		读操作;
		P(read_mutex);
		read_count--;
		if (read_count==0) V(read);
		V(read_mutex);
	}
}
void write(){
	while(1){
		P(write_mutex);
		if(write_count==0) P(write);
		write_count++;
		V(write_mutex);	
		P(read);
		写操作;
		V(read);
		P(write_mutex);
		write_count--;
		if(write_count==0) V(write);
		V(write_mutex);	
	}
}
void main(){
	cobegin
		reader();writer();
	coend
}

第四题

（4）桌上有一空盘，可放一只水果。爸爸可向盘中放苹果，也可向盘中放桔子；儿子专等吃盘中的桔子；女儿专等吃盘中的苹果。规定一次只能放一只水果，试写出爸爸、儿子、女儿正确同步的程序。

struct semaphore empte=1,orange=0,apple=0;
void father(){
	while(1){
		P(empty);
		获取一个水果;
		if(桔子) 
			V(orange);
		else 
			V(apple);
	}
}
void daughter(){
	while(1){
		P(apple);
		拿走苹果;
		V(empty);
	}
}
void son(){
	while(1){
		P(orange);
		拿走桔子;
		V(empty);
	}
}
void main(){
	cobegin
		father();daughter();son();
	coend
}

第五题

（5）三个进程P1、P2、P3互斥使用一个包含N（N>0）个单元的缓冲区。P1每次用produce（）生成一个正整数并用put（）送入缓冲区某一空单元中；P2每次用getodd（）从该缓冲区中取出一个奇数并用countodd（）统计奇数个数；P3每次用geteven（）从该缓冲区中取出一个偶数并用counteven（）统计偶数个数。请用信号量机制实现这三个进程的同步与互斥活动，并说明所定义的信号量的含义。要求用伪代码描述（2009年全国硕士研究生入学考试题）。

struct semaphore empty=N, mutex=1, odd=0, even=0;
void P1(){
	int num;
	while(1){
		num = produce();
		P(empty);
		P(mutex);
		put(num);
		if(num是奇数)
			V(odd);
		else
			V(even);
		V(mutex);
	}
}
void P2(){
	P(odd);
	P(mutex);
	getodd();
	countodd() = countodd() + 1;
	V(empyt);
	V(mutex);
}
void P3(){
	P(even);
	P(mutex);
	geteven();
	counteven() = counteven() + 1;
	V(empyt);
	V(mutex);
}
void main(){
	cobegin
		P1();P2();P3();
	coend
}

第六题

(6)某银行提供1个服务窗口和10个供顾客等待的座位。顾客到达银行时，若有空座位，则到取号机上领取一个号，等待叫号。取号机每次仅允许一位顾客使用。当营业员空闲时，通过叫号选取一位顾客，并为其服务。顾客和营业员的活动过程描述如下:

cobegin
{
process 顾客1 {
从取号机上获取一个号码；
等待叫号；
获取服务；
}
process 营业员 {
While(1) {
叫号；
为顾客服务；
}
}
}
coend

请添加必要的信号量和wait（）、signal（）操作，实现上述过程中的互斥与同步。要求写出完整的过程，说明信号量的含义并赋初值。（2011年全国硕士研究生入学考试题）

struct semaphore full=0,empty=10,window=1,machine=1;
process 顾客1{
	P(empty);
	P(machine);
	从取号机上获取一个号码;
	V(machine);
	V(full);
	等待叫号;
	P(window);
	获取服务;
	V(empty);
}
process 营业员{
	while(1){
		P(full);
		叫号;
		V(window);
		为顾客服务;
	}
}

第七题

（7）放小球问题：一个箱子里只有白色和黑色两种小球，且数量足够多。现在需要从中取出一些小球放入一个袋子中。约定：1）一次只能放入一个小球；2）白球的数量至多只能比黑球少N个，至多只能比黑球多M个（M，N为正整数）。请用信号量机制实现进程的同步与互斥。

struct semaphore get_mutex=1,put_mutex=1;
int black=0,white=0;
void put(){
	while(1){
		P(get_mutex);
		从箱子中拿出小球;
		V(get_mutex);
		P(put_mutex);
		if(白球){
			if(N > black - white){
				white++;	
				把球放进袋子;	
			}
		}else{
			if (M > white - black){
				black++;	
				把球放进袋子;	
			}
		}
		V(put_mutex);
	}
}