操作系统实验四吸烟者问题 201000130133计算机4班郑思雨--688IT编程网

计算机科学与技术学院实验报告

实验题目：实验四吸烟者问题

学号：201000130133

日期：2012-4-3

班级：计算机4班

姓名：郑思雨

Email：1412561943@qq

● 实验目的：

1、加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥操作的效果。

2、分析与研究经典进程同步与互斥问题的实际解决方案。

3、了解Linux系统中IPC进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。

● 硬件环境：

实验室计算机

● 软件环境：

语言编写。实验环境均为Linux操作系统

实验步骤：

1、了解实验的目的，了解并掌握与进程间通信IPC中的3个对象：共享内存、信号灯数组、

消息队列到呢个有关的系统调用，并能熟练的掌握。

2、阅读实验题目并分析实验的需求。

抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟，

抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个纸，

另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮

流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号

通知供应者，让它继续提供另外的两种材料。这一过程重复进行。请用以上介

绍的IPC同步机制编程，实现该问题要求的功能。

首先创建ipc.h文件，在里面定义生产者/消费者共用的IPC函数的原型和变量。

然后创建ipc.c文件，在里面定义生产者/消费者共用的IPC的具体的相应函数。

创建provider文件，在其中对生产者的一些行为进行定义，先利用系统调用创建共享内存区域，并设定他的长度并获取共享内存的首地址。

然后设定生产者互斥与同步的信号灯，并为他们设置相应的初值。当有生产者进程在运行而其他生产者请求时，相应的信号灯就会阻止他，当共享内存区域已满时，信号等也会提示生产者不能再往共享内存中放入内容。

三个生产者到底哪个应该运行，我们是采取选取随机数的方法进行的，通过随机数来确定应该有哪个进程运行，既有哪个生产者来进行生产。

创建smoker文件，在其中对消费者的一些行为进行定义，先利用系统调用来创建共享内存区域，并设定他的长度并获取共享内存的首地址。

然后设定消费者互斥与同步的信号灯，并为他们设置相应的初值。当有消费进程在运行而其他消费者请求时，相应的信号灯就会阻止它，当共享内存区域已空时，信号等也会提示生产者不能再从共享内存中取出相应的内容。

同样采取用随机数的方法来确定由哪个消费者来运行进程，但同时运行的消费者应该与相应的生产者对应起来，只有这样运行结果才会正确。

代码实现如下：

#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;

}

#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);

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 [3];

int prod_sem;

int pmtx_sem [3];

//消费者有关的信号量

key_t cons_key;

key_t cmtx_key[3];

int cons_sem;

int cmtx_sem[3];

int sem_val;

int sem_flg;

int shm_flg;

provider 部分：

#include "ipc.h"

int rand() { //用于产生生产者需要的随机数，随机数为0、1、2中的其一

srand((unsigned)time(NULL));

return random() % 3;

}

int main(int argc,char *argv[])

{

int rand() { //用于产生生产者需要的随机数，随机数为0、1、2中的其一

srand((unsigned)time(NULL));

return random() % 3;

}

int pid [2];

int i = 0,j;

int ppid = getpid();

for(i = 0;i<2;i++)

{

if((pid[i] = fork())<0)

{

perror("process not create");

exit(EXIT_FAILURE);

}

if(pid[i] == 0)

{

int rate;

//可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度

if(argv[1] != NULL) rate = atoi(argv[1]);

else rate = 1; //不指定为 3 秒

//共享内存使用的变量

buff_key = 1101;//缓冲区任给的键值

buff_num = 3;//缓冲区任给的长度

pput_key = 1102;//生产者放产品指针的键值

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

pmtx_key[0] = 1202;//生产者互斥信号灯键值

pmtx_key[1] = 1203;//生产者互斥信号灯键值

pmtx_key[2] = 1204;//生产者互斥信号灯键值

cmtx_key [0]= 1302;//消费者互斥信号灯键值

cmtx_key [1]= 1303;//消费者互斥信号灯键值

cmtx_key [2]= 1304;//消费者互斥信号灯键值

sem_flg = IPC_CREAT | 0644;

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

sem_val = 1;

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

prod_sem = set_sem(prod_key,sem_val,sem_flg);

//生产者tp信号灯初值为 1

sem_val = 1;

//获取生产者互斥信号灯,进程间通信实验总结引用标识存 pmtx_sem

pmtx_sem[0] = set_sem(pmtx_key[0],sem_val,sem_flg);

//生产者pg信号灯初值为 1

sem_val = 1;

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

pmtx_sem[1] = set_sem(pmtx_key[1],sem_val,sem_flg);

//生产者gt信号灯初值为 1

sem_val = 1;

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

pmtx_sem[2] = set_sem(pmtx_key[2],sem_val,sem_flg);

//消费者tp信号灯初值为 0

sem_val = 0;

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

cmtx_sem[0] = set_sem(cmtx_key[0],sem_val,sem_flg);

//消费者pg信号灯初值为 0

sem_val = 0;

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

cmtx_sem[1] = set_sem(cmtx_key[1],sem_val,sem_flg);

//消费者gt信号灯初值为 0

sem_val = 0;

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

cmtx_sem[2] = set_sem(cmtx_key[2],sem_val,sem_flg);

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

while(1){

j = rand();

//互斥锁

down(pmtx_sem[j]);

//同步锁

down(prod_sem);

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

buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;

sleep(rate);

switch(j) {

case 0:

printf("pid:%d--\tI'm the provider with tobacco \n", getpid());

break;

case 1:

printf("pid:%d--\tI'm the provider with glue \n", getpid());

break;

case 2:

printf("pid:%d--\tI'm the provider with tobacco \n", getpid());

break;

}

//printf("pid=%dproducer put %ctoBuffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);

//存放位置循环下移

//*pput_ptr = (*pput_ptr+1) % buff_num;

// 释放同步锁

up(prod_sem);

//唤醒阻塞的消费者

up(cmtx_sem[j]);

}

return EXIT_SUCCESS;

}

pause();

return EXIT_SUCCESS;

}

smoker部分：

#include "ipc.h"

int rand() { //用于产生生产者需要的随机数，随机数为0、1、2中的其一

srand((unsigned)time(NULL));

return random() % 3;

}

int main(int argc,char *argv[])

{

int pid [3];

int i,j ;

for(i = 0;i<3;i++)

{

if((pid[i] = fork())<0)

{

perror("process not create");

exit(EXIT_FAILURE);

}

if(pid[i] == 0)

{

int rate;

//可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度

if(argv[1] != NULL) rate = atoi(argv[1]);

else rate = 3; //不指定为 3 秒

//共享内存使用的变量

buff_key = 1101; //缓冲区任给的键值

buff_num = 3; //缓冲区任给的长度

cget_key = 1103; //消费者取产品指针的键值

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);

//信号量使用的变量

pmtx_key[0] = 1202;//生产者互斥信号灯键值

pmtx_key[1] = 1203;//生产者互斥信号灯键值

pmtx_key[2] = 1204;//生产者互斥信号灯键值

cons_key = 1301;//消费者同步信号灯键值

cmtx_key [0]= 1302;//消费者互斥信号灯键值

cmtx_key [1]= 1303;//消费者互斥信号灯键值

cmtx_key [2]= 1304;//消费者互斥信号灯键值

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

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

sem_val = 1;

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

cons_sem = set_sem(cons_key,sem_val,sem_flg);

//生产者tp信号灯初值为 1

sem_val = 0;

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

pmtx_sem[0] = set_sem(pmtx_key[0],sem_val,sem_flg);

//生产者pg信号灯初值为 1

sem_val = 0;

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

pmtx_sem[1] = set_sem(pmtx_key[1],sem_val,sem_flg);

//生产者gt信号灯初值为 1

sem_val = 0;

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

pmtx_sem[2] = set_sem(pmtx_key[2],sem_val,sem_flg);

//消费者tp信号灯初值为 0

sem_val = 0;

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

cmtx_sem[0] = set_sem(cmtx_key[0],sem_val,sem_flg);

//消费者pg信号灯初值为 0

sem_val = 0;

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

cmtx_sem[1] = set_sem(cmtx_key[1],sem_val,sem_flg);

//消费者gt信号灯初值为 0

sem_val = 0;

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

cmtx_sem[2] = set_sem(cmtx_key[2],sem_val,sem_flg);

if(pid[0] == 0)

{

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

while(1){

//互斥锁

down(cmtx_sem[0]);

//同步锁

down(cons_sem);

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

printf("pid:%d\tI'm smoker with glue. Get the tobacco and paper. Start \n", getpid());

sleep(rate);

//同步锁

up(cons_sem);

//唤醒阻塞的生产者

up(pmtx_sem[0]);

}

if(pid[1] == 0)

{

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

while(1){

//互斥锁

down(cmtx_sem[1]);

//同步锁

down(cons_sem);

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

sleep(rate);

printf("pid:%d\tI'm smoker with tobacco. Get the glue and paper. Start \n", getpid());

//同步锁

up(cons_sem);

//唤醒阻塞的生产者

up(pmtx_sem[1]);

}

if(pid[2] == 0)

{

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

while(1){

//互斥锁

down(cmtx_sem[2]);

//同步锁

down(cons_sem);

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

sleep(rate);

printf("pid:%d\tI'm smoker with paper. Get the tobacco and glue. Start \n", getpid());

//同步锁

up(cons_sem);

//唤醒阻塞的生产者

up(pmtx_sem[2]);

}

pause();

return EXIT_SUCCESS;

}

removeipc.c部分：

#include "ipc.h"

int main(){

prod_key = 1201;//生产者同步信号灯键值

pmtx_key[0] = 1202;//生产者互斥信号灯键值

pmtx_key[1] = 1203;//生产者互斥信号灯键值

pmtx_key[2] = 1204;//生产者互斥信号灯键值

cmtx_key [0]= 1302;//消费者互斥信号灯键值

cmtx_key [1]= 1303;//消费者互斥信号灯键值

cmtx_key [2]= 1304;//消费者互斥信号灯键值

int id;

Sem_uns sem_arg;

if((id=get_ipc_id("/proc/sysvipc/sem",prod_key))>=0){//删除已经建立的信号量