进程同步

生产者消费问题

# 信号量
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);
}