操作系统实验四之进程同步实验

最新推荐文章于 2024-06-23 20:53:34 发布

VIP_CQCRE

最新推荐文章于 2024-06-23 20:53:34 发布

阅读量1.1w

点赞数 5

分类专栏： C++ 操作系统 C 文章标签：操作系统 C OS

本文链接：https://blog.csdn.net/cqcre/article/details/26621655

版权

C 同时被 3 个专栏收录

17 篇文章 1 订阅

订阅专栏

C++

10 篇文章 5 订阅

订阅专栏

操作系统

7 篇文章 3 订阅

订阅专栏

/*
抽烟者问题。假设一个系统中有三个抽烟者进程,每个抽烟者不断地卷烟并抽烟。
抽烟者卷起并抽掉一颗烟需要有三种材料:烟草、纸和胶水。一个抽烟者有烟草,
一个有纸,另一个有胶水。系统中还有两个供应者进程,它们无限地供应所有三种
材料,但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起
并抽掉一颗烟后会发信号通知供应者,让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍的 IPC 同步机制编程,实现该问题要求的功能。
*/

ipc.h

#include <stdio.h>

#include <stdlib.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);//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;

//消费者有关的信号量

key_t c_PG_key;

key_t c_TP_key;

key_t c_TG_key;

key_t cmtx_key;

int c_PG_sem;

int c_TP_sem;

int c_TG_sem;

int cmtx_sem;

 

int sem_val;

int sem_flg;

int shm_flg;

ipc.c

#include "ipc.h"

 

int get_ipc_id(char *proc_file,key_t key)//获取IPC 的id 号

{

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;

}

 

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;

}

 

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;

}

consumer.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 = 3; //缓冲区任给的长度

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; //生产者同步信号灯键值

cmtx_key = 203; //生产者互斥信号灯键值

c_PG_key = 301;//消费者同步信号灯键值

c_TP_key = 302;//消费者互斥信号灯键值

c_TG_key = 303;//消费者互斥信号灯键值

sem_flg = IPC_CREAT | 0644; //信号灯操作权限

//生产者同步信号灯初值设为缓冲区最大可用量

sem_val = 1;

//获取生产者同步信号灯,引用标识存 prod_sem

prod_sem = set_sem(prod_key,sem_val,sem_flg);

//消费者初始无产品可取,同步信号灯初值设为 0

sem_val = 0;

//获取消费者同步信号灯,引用标识存 cons_sem

c_PG_sem = set_sem(c_PG_key,sem_val,sem_flg);

c_TP_sem = set_sem(c_TP_key,sem_val,sem_flg);

c_TG_sem = set_sem(c_TG_key,sem_val,sem_flg);

//消费者互斥信号灯初值为 1

sem_val = 1;

//获取消费者互斥信号灯,引用标识存 cmtx_sem

cmtx_sem = set_sem(cmtx_key,sem_val,sem_flg);

int pid1, pid2;

pid1 = fork();

if(pid1 == 0) {

    //循环执行模拟消费者不断取产品

    while(1){

        //如果无产品消费者阻塞

        down(c_PG_sem);

        //如果另一消费者正在取产品,本消费者阻塞

        down(cmtx_sem);

        //用读一字符的形式模拟消费者取产品,报告本进程号和获取的字符及读取的位置

        sleep(rate);

        printf("%d吸烟者有烟草T,得到纸%c和胶水%c,开始吸烟……\n",

            getpid(),buff_ptr[*cget_ptr + 1],buff_ptr[*cget_ptr + 2]);

        //唤醒阻塞的消费者

        up(cmtx_sem);

        //唤醒阻塞的生产者

        up(prod_sem);

    }

} else {

    pid2 = fork();

    if(pid2 == 0) {

        //循环执行模拟消费者不断取产品

        while(1){

            //如果无产品消费者阻塞

            down(c_TP_sem);

            //如果另一消费者正在取产品,本消费者阻塞

            down(cmtx_sem);

            //用读一字符的形式模拟消费者取产品,报告本进程号和获取的字符及读取的位置

            sleep(rate);

            printf("%d吸烟者有胶水G,得到纸%c和烟草%c,开始吸烟……\n",

                getpid(),buff_ptr[*cget_ptr + 1],buff_ptr[*cget_ptr]);

            //唤醒阻塞的消费者

            up(cmtx_sem);

            //唤醒阻塞的生产者

            up(prod_sem);

        }

    } else {

        //循环执行模拟消费者不断取产品

        while(1){

            //如果无产品消费者阻塞

            down(c_TG_sem);

            //如果另一消费者正在取产品,本消费者阻塞

            down(cmtx_sem);

            //用读一字符的形式模拟消费者取产品,报告本进程号和获取的字符及读取的位置

            sleep(rate);

            printf("%d吸烟者有纸P,得到胶水%c和烟草%c,开始吸烟……\n",

                getpid(),buff_ptr[*cget_ptr + 2],buff_ptr[*cget_ptr]);

            //唤醒阻塞的消费者

            up(cmtx_sem);

            //唤醒阻塞的生产者

            up(prod_sem);

        }

        }

}

return EXIT_SUCCESS;

}

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 = 3;//缓冲区任给的长度

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;//生产者互斥信号灯键值

c_PG_key = 301;//消费者同步信号灯键值

c_TP_key = 302;//消费者互斥信号灯键值

c_TG_key = 303;//消费者互斥信号灯键值

sem_flg = IPC_CREAT | 0644;

//生产者同步信号灯初值设为缓冲区最大可用量

sem_val = 1;

//获取生产者同步信号灯,引用标识存 prod_sem

prod_sem = set_sem(prod_key,sem_val,sem_flg);

//消费者初始无产品可取,同步信号灯初值设为 0

sem_val = 0;

//获取消费者同步信号灯,引用标识存 cons_sem

c_PG_sem = set_sem(c_PG_key,sem_val,sem_flg);

c_TP_sem = set_sem(c_TP_key,sem_val,sem_flg);

c_TG_sem = set_sem(c_TG_key,sem_val,sem_flg);

//生产者互斥信号灯初值为 1

sem_val = 1;

//获取生产者互斥信号灯,引用标识存 pmtx_sem

pmtx_sem = set_sem(pmtx_key,sem_val,sem_flg);

//循环执行模拟生产者不断放产品

int pid;

int i;

pid = fork();

if(pid == 0) {

    while(1){

        int r = rand() % 3;

        if(r == 0) {

             down(prod_sem);

            //如果另一生产者正在放产品,本生产者阻塞

            down(pmtx_sem);

            //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置

            buff_ptr[*pput_ptr + 1] = 'P';//p纸 G 胶水  T烟草

            buff_ptr[*pput_ptr + 2] = 'G';

            sleep(rate);

            printf("%d供应商提供：纸%c,胶水%c\n",getpid(),buff_ptr[*pput_ptr + 1] ,buff_ptr[*pput_ptr + 2]);

            //唤醒阻塞的生产者

            up(pmtx_sem);

            //唤醒阻塞的消费者

            up(c_PG_sem);

        } else if(r == 1) {

             down(prod_sem);

            //如果另一生产者正在放产品,本生产者阻塞

            down(pmtx_sem);

            //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置

            buff_ptr[*pput_ptr] = 'T';

            buff_ptr[*pput_ptr + 2] = 'G';

            sleep(rate);

            printf("%d供应商提供：烟草%c,胶水%c\n",getpid(),buff_ptr[*pput_ptr] ,buff_ptr[*pput_ptr + 2]);

            //唤醒阻塞的生产者

            up(pmtx_sem);

            //唤醒阻塞的消费者

            up(c_TG_sem);

        } else if(r == 2) {

             down(prod_sem);

            //如果另一生产者正在放产品,本生产者阻塞

            down(pmtx_sem);

            //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置

            buff_ptr[*pput_ptr + 1] = 'P';

            buff_ptr[*pput_ptr] = 'T';

            sleep(rate);

            printf("%d供应商提供：烟草%c,纸%c\n",getpid(),buff_ptr[*pput_ptr] ,buff_ptr[*pput_ptr + 1]);

            //唤醒阻塞的生产者

            up(pmtx_sem);

            //唤醒阻塞的消费者

            up(c_TP_sem);

        }

    }

} else {

    while(1){

        int r = rand() % 3;

        if(r == 0) {

             down(prod_sem);

            //如果另一生产者正在放产品,本生产者阻塞

            down(pmtx_sem);

            //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置

            buff_ptr[*pput_ptr + 1] = 'P';

            buff_ptr[*pput_ptr + 2] = 'G';

            sleep(rate);

            printf("%d供应商提供：纸%c,胶水%c\n",getpid(),buff_ptr[*pput_ptr + 1] ,buff_ptr[*pput_ptr + 2]);

            //唤醒阻塞的生产者

            up(pmtx_sem);

            //唤醒阻塞的消费者

            up(c_PG_sem);

        } else if(r == 1) {

             down(prod_sem);

            //如果另一生产者正在放产品,本生产者阻塞

            down(pmtx_sem);

            //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置

            buff_ptr[*pput_ptr] = 'T';

            buff_ptr[*pput_ptr + 2] = 'G';

            sleep(rate);

            printf("%d供应商提供：烟草%c,胶水%c\n",getpid(),buff_ptr[*pput_ptr] ,buff_ptr[*pput_ptr + 2]);

            //唤醒阻塞的生产者

            up(pmtx_sem);

            //唤醒阻塞的消费者

            up(c_TG_sem);

        } else if(r == 2) {

             down(prod_sem);

            //如果另一生产者正在放产品,本生产者阻塞

            down(pmtx_sem);

            //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置

            buff_ptr[*pput_ptr + 1] = 'P';

            buff_ptr[*pput_ptr] = 'T';

            sleep(rate);

            printf("%d供应商提供：烟草%c,纸%c\n",getpid(),buff_ptr[*pput_ptr] ,buff_ptr[*pput_ptr + 1]);

            //唤醒阻塞的生产者

            up(pmtx_sem);

            //唤醒阻塞的消费者

            up(c_TP_sem);

        }

    }

}

return EXIT_SUCCESS;

}

makefile

hdrs = ipc.h
opts = -g -c
c_src = consumer.c ipc.c
c_obj = consumer.o ipc.o
p_src = producer.c ipc.c
p_obj = producer.o ipc.o
all:  producer consumer
consumer:$(c_obj)
	gcc $(c_obj) -o consumer
consumer.o:$(c_src) $(hdrs)
	gcc $(opts) $(c_src)
producer: $(p_obj)
	gcc $(p_obj) -o producer
producer.o: $(p_src) $(hdrs)
	gcc $(opts) $(p_src)
clean:
	rm consumer producer *.o

VIP_CQCRE

关注

5
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
操作系统实验四之进程同步实验

/*抽烟者问题。假设一个系统中有三个抽烟者进程,每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料:烟草、纸和胶水。一个抽烟者有烟草,一个有纸,另一个有胶水。系统中还有两个供应者进程,它们无限地供应所有三种材料,但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者,让它继续提供另外的两种材料。这一过程重复进行。请用以上介绍的
复制链接

扫一扫

专栏目录