【操作系统】信号量处理同步互斥问题，多生产者多消费者问题、前趋关系问题

多生产者多消费者问题

一家人吃水果问题是生产者消费者问题的一种变形。问题如下：

• 桌子上有一只盘子，每次只能放一个水果；
• 爸爸专向里面放苹果，妈妈专放桔子；
• 儿子专吃苹果，女儿专吃桔子；
• 仅当盘子空闲时，爸爸妈妈才可以向里面放水果；
• 仅当盘子里有自己需要的水果时，儿子女儿才可以从里面取出一只水果。

试利用线程模拟这个问题，并进行正确的同步。

提示：

• 共使用3个信号量（注意信号量初始值的设定）：
  • empty: 盘子空信号量
  • apple: 苹果信号量
  • orange: 橘子信号量
• 共创建4个线程：父亲线程，母亲线程，儿子线程，女儿线程。

分析：这里有两个生产者，即爸爸和妈妈；两个消费者，即儿子和女儿。一个临界资源，即盘子。

接下来我们进行代码实现：

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
//much producer and consumer
//capacity
#define N 1
sem_t apple,orange,empty;

void* mom(void* args){
	sem_wait(&empty);
	printf("Mom lay an orange for the %d time\n",(int)args);
	sem_post(&orange);
}

void* dad(void* args){
	sem_wait(&empty);
	printf("Dad lay an apple for the %d time\n",(int)args);
	sem_post(&apple);
}

void* son(void* args){
	sem_wait(&orange);
	printf("son eat an orange for the %d time\n",(int)args);
	sem_post(&empty);
}

void* dau(void* args){
	sem_wait(&apple);
	printf("daughter eat an apple for the %d time\n",(int)args);
	sem_post(&empty);
}



int main(){
	pthread_t pmom;
	pthread_t pdad;
	pthread_t pson;
	pthread_t pdau;
	int i = 1;


	sem_init(&apple,0,0);
	sem_init(&orange,0,0);
	sem_init(&empty,0,N);

	pthread_create(&pmom, NULL, mom, (void*)i);
	pthread_create(&pdad, NULL, dad, (void*)i);
	pthread_create(&pson, NULL, son, (void*)i);
	pthread_create(&pdau, NULL, dau, (void*)i);

    pthread_join(pmom, NULL);
	pthread_join(pdad, NULL);
	pthread_join(pson, NULL);
	pthread_join(pdau, NULL);

}

这里的同步关系为：

• 对于父母来说盘子为空才能放；

• 对于女儿来说，盘子有苹果才能取；

• 对于儿子来说，盘子有橘子才能取。

但是这里无需用到互斥，因为这里盘子的容量为1，即缓冲区的容量为1。

解决此类问题的关键是，前操作之后执行V，后操作之前执行P

对于水果来说，放水果是前操作,拿水果是后操作。

输出结果：

前趋关系

为实现以上前趋关系，很明显我们可以创建5个信号量a,b,c,d,e

代码实现:

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>

sem_t a,b,c,d,e;

void* S1(void* arg){
	printf("S1\n");
	sem_post(&a);
	sem_post(&a);
}

void* S2(void* arg){
	sem_wait(&a);
	printf("S2\n");
	sem_post(&b);
	sem_post(&b);
}

void* S3(void* arg){
	sem_wait(&a);
	printf("S3\n");
	sem_post(&e);
}

void* S4(void* arg){
 	sem_wait(&b);
	printf("S4\n");
	sem_post(&c);
}

void* S5(void* arg){
 	sem_wait(&b);
	printf("S5\n");
	sem_post(&d);
}

void* S6(void* arg){
 	sem_wait(&c);
	sem_wait(&e);
	printf("S6\n");
}


int main(){
	pthread_t id[6];
    //初始化信号量，默认值都为0
	sem_init(&a,0,0);
	sem_init(&b,0,0);
	sem_init(&c,0,0);
	sem_init(&d,0,0);
	sem_init(&e,0,0);
	
	pthread_create(&id[0], NULL, S1, NULL);
	pthread_create(&id[1], NULL, S2, NULL);
	pthread_create(&id[2], NULL, S3, NULL);
	pthread_create(&id[3], NULL, S4, NULL);
	pthread_create(&id[4], NULL, S5, NULL);
	pthread_create(&id[5], NULL, S6, NULL);

	pthread_join(id[0], NULL);
	pthread_join(id[1], NULL);
	pthread_join(id[2], NULL);
	pthread_join(id[3], NULL);
	pthread_join(id[4], NULL);
	pthread_join(id[5], NULL);
}

其实就是等待哪个、释放哪个、释放几个

这里S1跟S2被两个线程所等待，每个线程都会让信号量自减1。为了满足两个线程的需求，所以释放了两次信号量。

当然，如果设置7个信号量，则每个只需释放一次

多次执行，结果如下，可以正确表示前趋关系