操作系统 吸烟者问题 进程的同步互斥

操作系统 吸烟者问题 进程的同步互斥
这个解释的挺清楚的:https://www.cnblogs.com/wkfvawl/p/11534452.html

代码:
producer.c

#include "ipc.h"

int main(int argc, char *argv[]) {
	int rate; 
	//可在在命令⾏第⼀参数指定⼀个进程睡眠秒数,以调解进程执⾏速度
 	if (argv[1] != NULL) rate = atoi(argv[1]);
 	else rate = 3; //不指定则默认为 3 秒

	//共享内存使⽤的变量
 	buff_key = 101;//缓冲区任给的键值
 	buff_num = 1;//缓冲区任给的⻓度
 	pput_key = 102;//⽣产者放产品指针的键值
 	pput_num = 1; //指针数
 	shm_flg = IPC_CREAT | 0644;//共享内存读写权限
 	
	//获取缓冲区使⽤的共享内存,buff_ptr 指向缓冲区⾸地址
 	buff_ptr = (char *)set_shm(buff_key, buff_num, shm_flg);
 	
	//获取⽣产者放产品位置指针 pput_ptr
 	pput_ptr = (int *)set_shm(pput_key, pput_num, shm_flg);
 	
	//信号量使⽤的变量
 	prod_key = 201;//⽣产者同步信号灯键值
 	pmtx_key = 202;//⽣产者互斥信号灯键值
 	cons1_key = 301;//消费者1同步信号灯键值
	cons2_key = 302;//消费者2同步信号灯键值
	cons3_key = 303;//消费者3同步信号灯键值
 	sem_flg = IPC_CREAT | 0644;
 	
	//⽣产者同步信号灯初值设为缓冲区最⼤可⽤量
	sem_val = buff_num;
 	//获取⽣产者同步信号灯,引⽤标识存 prod_sem
 	prod_sem = set_sem(prod_key, sem_val, sem_flg);
 	
	//⽣产者互斥信号灯初值为 1
 	sem_val = 1;
 	//获取⽣产者互斥信号灯,引⽤标识存 pmtx_sem
 	pmtx_sem = set_sem(pmtx_key, sem_val, sem_flg);
	
	//消费者初始⽆产品可取,同步信号灯初值设为 0
 	sem_val = 0;
 	//获取消费者同步信号灯,引⽤标识存 cons_sem
 	cons1_sem = set_sem(cons1_key, sem_val, sem_flg);
	cons2_sem = set_sem(cons2_key, sem_val, sem_flg);
	cons3_sem = set_sem(cons3_key, sem_val, sem_flg);
	
	while(1) {

		down(prod_sem);

		//如果另一生产者正在放产品,本生产者阻塞  
		down(pmtx_sem);
		
		int x = rand()%3;

		if(x == 0) {
			printf("The producer(%d) gives tobacco and paper\n", getpid());
			//唤醒阻塞的⽣产者
			up(pmtx_sem);
			
			up(cons1_sem);
		} else if(x == 1) {
			printf("The producer(%d) gives tobacco and glue\n", getpid());
			//唤醒阻塞的⽣产者
			up(pmtx_sem);
			
			up(cons2_sem);
		} else if(x == 2) {
			printf("The producer(%d) gives glue and paper\n", getpid());
			//唤醒阻塞的⽣产者
			up(pmtx_sem);
			
			up(cons3_sem);
		}
		sleep(rate);
		
	}
 	return EXIT_SUCCESS;
}

consumer1.c

#include "ipc.h"

int main(int argc, char *argv[]) {
 	int rate;
 	//可在在命令⾏第⼀参数指定⼀个进程睡眠秒数,以调解进程执⾏速度
 	if (argv[1] != NULL) rate = atoi(argv[1]);
 	else rate = 3; //不指定为 3 秒
 	 
	//共享内存 使⽤的变量
 	buff_key = 101; //缓冲区任给的键值
 	buff_num = 1; //缓冲区任给的⻓度
 	cget_key = 103; //消费者取产品指针的键值
 	cget_num = 1; //指针数
 	shm_flg = IPC_CREAT | 0644; //共享内存读写权限
 	
	//获取缓冲区使⽤的共享内存,buff_ptr 指向缓冲区⾸地址
 	buff_ptr = (char *)set_shm(buff_key, buff_num, shm_flg);
 	
	//获取消费者取产品指针,cget_ptr 指向索引地址
 	cget_ptr = (int *)set_shm(cget_key, cget_num, shm_flg);
 	
	//信号量使⽤的变量
 	prod_key = 201; //⽣产者同步信号灯键值
 	pmtx_key = 202; //⽣产者互斥信号灯键值
 	cons1_key = 301; //消费者同步信号灯键值
 	sem_flg = IPC_CREAT | 0644; //信号灯操作权限
 	
	//⽣产者同步信号灯初值设为缓冲区最⼤可⽤量
 	sem_val = buff_num;
 	//获取⽣产者同步信号灯,引⽤标识存 prod_sem
 	prod_sem = set_sem(prod_key, sem_val, sem_flg);
 	
	//消费者初始⽆产品可取,同步信号灯初值设为 0
 	sem_val = 0;
 	//获取消费者1同步信号灯,引⽤标识存 cons1_sem
 	cons1_sem = set_sem(cons1_key, sem_val, sem_flg);
 	
	int cnt = 0;

	//循环执⾏模拟消费者不断取产品
 	while (1) {
 		//如果⽆产品,消费者阻塞
		down(cons1_sem);

 		sleep(rate);
		printf("%d glue - smooke success, times = %d\n", getpid(), ++cnt);
 	
 		//唤醒阻塞的⽣产者
 		up(prod_sem);
 	}
 	return EXIT_SUCCESS;
}

consumer2.c

#include "ipc.h"

int main(int argc, char *argv[]) {
 	int rate;
 	// 可在在命令⾏第⼀参数指定⼀个进程睡眠秒数,以调解进程执⾏速度
 	if (argv[1] != NULL) rate = atoi(argv[1]);
 	else rate = 3; //不指定为 3 秒
 	 
	//共享内存 使⽤的变量
 	buff_key = 101; //缓冲区任给的键值
 	buff_num = 1; //缓冲区任给的⻓度
 	cget_key = 103; //消费者取产品指针的键值
 	cget_num = 1; //指针数
 	shm_flg = IPC_CREAT | 0644; //共享内存读写权限
 	
	//获取缓冲区使⽤的共享内存,buff_ptr 指向缓冲区⾸地址
 	buff_ptr = (char *)set_shm(buff_key, buff_num, shm_flg);
 	
	//获取消费者取产品指针,cget_ptr 指向索引地址
 	cget_ptr = (int *)set_shm(cget_key, cget_num, shm_flg);
 	
	//信号量使⽤的变量
 	prod_key = 201; //⽣产者同步信号灯键值
 	pmtx_key = 202; //⽣产者互斥信号灯键值
 	cons2_key = 302; //消费者同步信号灯键值
 	sem_flg = IPC_CREAT | 0644; //信号灯操作权限
 	
	//⽣产者同步信号灯初值设为缓冲区最⼤可⽤量
 	sem_val = buff_num;
 	//获取⽣产者同步信号灯,引⽤标识存 prod_sem
 	prod_sem = set_sem(prod_key, sem_val, sem_flg);
 	
	//消费者初始⽆产品可取,同步信号灯初值设为 0
 	sem_val = 0;
 	//获取消费者同步信号灯,引⽤标识存 cons2_sem
 	cons2_sem = set_sem(cons2_key, sem_val, sem_flg);

	int cnt = 0;

	//循环执⾏模拟消费者不断取产品`
 	while (1) {
 		//如果⽆产品,消费者阻塞
 		down(cons2_sem);
 		
		//⽤读⼀字符的形式模拟消费者取产品,报告本进程号和获取的字符及读取的位置
 		sleep(rate);
		printf("%d paper - smooke success, times = %d\n", getpid(), ++cnt);

 		//唤醒阻塞的⽣产者
 		up(prod_sem);
 	}
 	return EXIT_SUCCESS;
}

consumer3.c

#include "ipc.h"

int main(int argc, char *argv[]) {
 	int rate;
 	//可在在命令⾏第⼀参数指定⼀个进程睡眠秒数,以调解进程执⾏速度
 	if (argv[1] != NULL) rate = atoi(argv[1]);
 	else rate = 3; //不指定为 3 秒
 	
	 
	//共享内存 使⽤的变量
 	buff_key = 101; //缓冲区任给的键值
 	buff_num = 1; //缓冲区任给的⻓度
 	cget_key = 103; //消费者取产品指针的键值
 	cget_num = 1; //指针数
 	shm_flg = IPC_CREAT | 0644; //共享内存读写权限
 	
	//获取缓冲区使⽤的共享内存,buff_ptr 指向缓冲区⾸地址
 	buff_ptr = (char *)set_shm(buff_key, buff_num, shm_flg);
 	
	//获取消费者取产品指针,cget_ptr 指向索引地址
 	cget_ptr = (int *)set_shm(cget_key, cget_num, shm_flg);
 	
	//信号量使⽤的变量
 	prod_key = 201; //⽣产者同步信号灯键值
 	pmtx_key = 202; //⽣产者互斥信号灯键值
 	cons3_key = 303; //消费者同步信号灯键值
 	sem_flg = IPC_CREAT | 0644; //信号灯操作权限
 	
	//⽣产者同步信号灯初值设为缓冲区最⼤可⽤量
 	sem_val = buff_num;
 	//获取⽣产者同步信号灯,引⽤标识存 prod_sem
 	prod_sem = set_sem(prod_key, sem_val, sem_flg);
 	
	//消费者初始⽆产品可取,同步信号灯初值设为 0
 	sem_val = 0;
 	//获取消费者同步信号灯,引⽤标识存 cons3_sem
 	cons3_sem = set_sem(cons3_key, sem_val, sem_flg);
 	
	int cnt = 0;

	//循环执⾏模拟消费者不断取产品
 	while (1) {
 		//如果⽆产品,消费者阻塞
 		down(cons3_sem);
 		
		//⽤读⼀字符的形式模拟消费者取产品,报告本进程号和获取的字符及读取的位置
 		sleep(rate);
		printf("%d tabacco - smooke success, times = %d\n", getpid(), ++cnt);

 		//唤醒阻塞的⽣产者
 		up(prod_sem);
 	}
 	return EXIT_SUCCESS;
}

ipc.h

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>

#define BUFSZ 256

//建⽴或获取 ipc 的⼀组函数的原型说明
int get_ipc_id(char *proc_file,key_t key);
char *set_shm(key_t shm_key,int shm_num,int shm_flag);
int set_msq(key_t msq_key,int msq_flag);
int set_sem(key_t sem_key,int sem_val,int sem_flag);
int down(int sem_id);
int up(int sem_id);

/*信号灯控制⽤的共同体*/
typedef union semuns {
 int val;
} Sem_uns;

/* 消 息 结 构 体 */
typedef struct msgbuf {
 long mtype;
 char mtext[1];
} Msg_buf;

//⽣产消费者共享缓冲区即其有关的变量
key_t buff_key;
int buff_num;
char *buff_ptr;

//⽣产者放产品位置的共享指针
key_t pput_key;
int pput_num;
int *pput_ptr;

//消费者取产品位置的共享指针
key_t cget_key;
int cget_num;
int *cget_ptr;

//⽣产者有关的信号量
key_t prod_key;
key_t pmtx_key;
int prod_sem;
int pmtx_sem;
int p_type1, p_type2, p_type3;
int all_product;

//消费者有关的信号量
key_t cons1_key;
key_t cmtx1_key;
key_t cons2_key;
key_t cmtx2_key;
key_t cons3_key;
key_t cmtx3_key;
int cons1_sem;
int cmtx1_sem;
int cons2_sem;
int cmtx2_sem;
int cons3_sem;
int cmtx3_sem;

int sem_val;
int sem_flg;
int shm_flg;

ipc.c

/*
* Filename  : ipc.c
* copyright : (C) 2006 by zhonghonglie
* Function  : 一组建立 IPC 机制的函数
*/
#include "ipc.h"
/*
* get_ipc_id() 从/proc/sysvipc/文件系统中获取 IPC 的 id 号
* pfile: 对应/proc/sysvipc/目录中的 IPC 文件分别为
* msg-消息队列,sem-信号量,shm-共享内存
* key:  对应要获取的 IPC 的 id 号的键值
*/
int get_ipc_id(char *proc_file, key_t key) {
    FILE *pf; int i, j;
    char line[BUFSZ], colum[BUFSZ];

    if ((pf = fopen(proc_file, "r")) == NULL) {
        perror("Proc file not open");
        exit(EXIT_FAILURE);
    }
    fgets(line, BUFSZ, pf);
    while (!feof(pf)) {
        i = j = 0;
        fgets(line, BUFSZ, pf);
        while (line[i] == ' ') i++;
        while (line[i] != ' ') colum[j++] = line[i++];
        colum[j] = '\0';
        if (atoi(colum) != key) continue;
        j = 0;
        while (line[i] == ' ') i++;
        while (line[i] != ' ') colum[j++] = line[i++];
        colum[j] = '\0';
        i = atoi(colum);
        fclose(pf);
        return i;
    }
    fclose(pf);
    return -1;
}



/*
* 信号灯上的down/up 操作
* semid:信号灯数组标识符
* semnum:信号灯数组下标
* buf:操作信号灯的结构
*/
int down(int sem_id) {
    struct sembuf buf;
    buf.sem_op = -1;
    buf.sem_num = 0;
    buf.sem_flg = SEM_UNDO;
    if ((semop(sem_id, &buf, 1)) < 0) {
        perror("down error ");
        exit(EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
}

int up(int sem_id) {
    struct sembuf buf;
    buf.sem_op = 1;
    buf.sem_num = 0;
    buf.sem_flg = SEM_UNDO;
    if ((semop(sem_id, &buf, 1)) < 0) {
        perror("up error ");
        exit(EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
}


/*
* set_sem 函数建立一个具有 n 个信号灯的信号量
* 如果建立成功,返回 一个信号灯数组的标识符 sem_id
* 输入参数:
* sem_key 信号灯数组的键值
* sem_val 信号灯数组中信号灯的个数
* sem_flag 信号等数组的存取权限
*/
int set_sem(key_t sem_key, int sem_val, int sem_flg) {
    int sem_id;
    Sem_uns sem_arg;
    //测试由 sem_key 标识的信号灯数组是否已经建立
    if ((sem_id = get_ipc_id("/proc/sysvipc/sem", sem_key)) < 0 ) {
        //semget 新建一个信号灯,其标号返回到 sem_id
        if ((sem_id = semget(sem_key, 1, sem_flg)) < 0) {
            perror("semaphore create error");
            exit(EXIT_FAILURE);
        }
        //设置信号灯的初值
        sem_arg.val = sem_val;
        if (semctl(sem_id, 0, SETVAL, sem_arg) < 0) {
            perror("semaphore set error");
            exit(EXIT_FAILURE);
        }
    }
    return sem_id;
}


/*
* set_shm 函数建立一个具有 n 个字节 的共享内存区
* 如果建立成功,返回 一个指向该内存区首地址的指针 shm_buf
* 输入参数:
* shm_key 共享内存的键值
* shm_val 共享内存字节的长度
* shm_flag 共享内存的存取权限
*/
char *set_shm(key_t shm_key, int shm_num, int shm_flg) {
    int i, shm_id;
    char *shm_buf;
    //测试由 shm_key 标识的共享内存区是否已经建立
    if ((shm_id = get_ipc_id("/proc/sysvipc/shm", shm_key)) < 0 ) {
        //shmget 新建 一个长度为 shm_num 字节的共享内存,其标号返回shm_id
        if ((shm_id = shmget(shm_key, shm_num, shm_flg)) < 0) {
            perror("shareMemory set error"); exit(EXIT_FAILURE);
        }
        //shmat 将由 shm_id 标识的共享内存附加给指针 shm_buf
        if ((shm_buf = (char *)shmat(shm_id, 0, 0)) < (char *)0) {
            perror("get shareMemory error"); exit(EXIT_FAILURE);
        }
        for (i = 0; i < shm_num; i++) shm_buf[i] = 0; //初始为 0
    }
    //shm_key 标识的共享内存区已经建立,将由 shm_id 标识的共享内存附加给指针 shm_buf
    if ((shm_buf = (char *)shmat(shm_id, 0, 0)) < (char *)0) {
        perror("get shareMemory error");
        exit(EXIT_FAILURE);
    }

    return shm_buf;
}

/*
* set_msq 函数建立一个消息队列
* 如果建立成功,返回 一个消息队列的标识符 msq_id
* 输入参数:
* msq_key 消息队列的键值
* msq_flag 消息队列的存取权限
*/
int set_msq(key_t msq_key, int msq_flg) {
    int msq_id;
    //测试由 msq_key 标识的消息队列是否已经建立
    if ((msq_id = get_ipc_id("/proc/sysvipc/msg", msq_key)) < 0 ) {
        //msgget 新建一个消息队列,其标号返回到 msq_id
        if ((msq_id = msgget(msq_key, msq_flg)) < 0) {
            perror("messageQueue set error"); exit(EXIT_FAILURE);
        }
    }
    return msq_id;
}

makefile

hdrs = ipc.h
opts = -g -c
c1_src = consumer1.c ipc.c
c1_obj = consumer1.o ipc.o
c2_src = consumer2.c ipc.c
c2_obj = consumer2.o ipc.o
c3_src = consumer3.c ipc.c
c3_obj = consumer3.o ipc.o
p_src = producer.c ipc.c
p_obj = producer.o ipc.o
all:	producer consumer1 consumer2 consumer3

consumer1:	$(c1_obj)
			gcc $(c1_obj) -o consumer1
consumer1.o:	$(c1_src) $(hdrs)
			gcc $(opts) $(c1_src)

consumer2:	$(c2_obj)
			gcc $(c2_obj) -o consumer2
consumer2.o:	$(c2_src) $(hdrs)
			gcc $(opts) $(c2_src)

consumer3:	$(c3_obj)
			gcc $(c3_obj) -o consumer3
consumer3.o:	$(c3_src) $(hdrs)
			gcc $(opts) $(c3_src)

producer:$(p_obj)
			gcc $(p_obj) -o producer
producer.o:	$(p_src) $(hdrs)
			gcc $(opts) $(p_src)
clean:
			rm consumer producer *.o

  • 0
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
下面是一个基于信号量的解法的C语言代码实现: ```c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <semaphore.h> #include <unistd.h> #define N 3 // 最大吸烟者数量 sem_t tobacco; // 烟草 sem_t paper; // 纸 sem_t matches; // 火柴 sem_t agent; // 客服 void* smoker_tobacco(void* arg); // 吸烟者1 void* smoker_paper(void* arg); // 吸烟者2 void* smoker_matches(void* arg); // 吸烟者3 void* agent_func(void* arg); // 客服 int main() { pthread_t smoker1, smoker2, smoker3, a; sem_init(&tobacco, 0, 0); sem_init(&paper, 0, 0); sem_init(&matches, 0, 0); sem_init(&agent, 0, 1); if (pthread_create(&smoker1, NULL, smoker_tobacco, NULL) != 0) { perror("pthread_create error"); exit(1); } if (pthread_create(&smoker2, NULL, smoker_paper, NULL) != 0) { perror("pthread_create error"); exit(1); } if (pthread_create(&smoker3, NULL, smoker_matches, NULL) != 0) { perror("pthread_create error"); exit(1); } if (pthread_create(&a, NULL, agent_func, NULL) != 0) { perror("pthread_create error"); exit(1); } pthread_join(smoker1, NULL); pthread_join(smoker2, NULL); pthread_join(smoker3, NULL); pthread_join(a, NULL); sem_destroy(&tobacco); sem_destroy(&paper); sem_destroy(&matches); sem_destroy(&agent); return 0; } void* smoker_tobacco(void* arg) { while (1) { sem_wait(&tobacco); printf("Smoker1 got tobacco.\n"); sleep(1); // 吸烟 sem_post(&agent); } } void* smoker_paper(void* arg) { while (1) { sem_wait(&paper); printf("Smoker2 got paper.\n"); sleep(1); // 吸烟 sem_post(&agent); } } void* smoker_matches(void* arg) { while (1) { sem_wait(&matches); printf("Smoker3 got matches.\n"); sleep(1); // 吸烟 sem_post(&agent); } } void* agent_func(void* arg) { int item; while (1) { sem_wait(&agent); item = rand() % 3; switch (item) { case 0: // 提供烟草和纸 printf("Agent put tobacco and paper on the table.\n"); sem_post(&matches); break; case 1: // 提供烟草和火柴 printf("Agent put tobacco and matches on the table.\n"); sem_post(&paper); break; case 2: // 提供纸和火柴 printf("Agent put paper and matches on the table.\n"); sem_post(&tobacco); break; } } } ``` 这个程序中,使用了4个信号量: - tobacco、paper、matches:表示烟草、纸、火柴的可用状态,初值均为0。 - agent:表示客服的可用状态,初值为1。 吸烟者和客服都是一个无限循环的线程。当客服(agent)发现桌子上有两种需要的材料时,就放开一个信号量,使得对应的吸烟者线程可以获得需要的材料,然后进行吸烟。吸烟者吸烟完毕后,又放开了一个信号量,使得客服线程可以开始下一轮提供材料。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值