1 上机实验一
1.1 实验内容
以下示例实验程序应能模拟多个生产／消费者在有界缓冲上正确的操作。它利用 N 个字节的共享内存作为有界循环缓冲区，利用写一字符模拟放一个产品，利用读一字符模拟消费一个产品。当缓冲区空时消费者应阻塞睡眠，而当缓冲区满时生产者应当阻塞睡眠。一旦缓冲区中有空单元，生产者进程就向空单元中入写字符，并报告写的内容和位置。一旦缓冲区中有未读过的字符，消费者进程就从该单元中读出字符，并报告读取位置。生产者不能向同一单元中连续写两次以上相同的字符，消费者也不能从同一单元中连续读两次以上相同的字符。以下示例实验程序应能模拟多个生产／消费者在有界缓冲上正确的操作。它利用 N 个字节的共享内存作为有界循环缓冲区，利用写一字符模拟放一个产品，利用读一字符模拟消费一个产品。当缓冲区空时消费者应阻塞睡眠，而当缓冲区满时生产者应当阻塞睡眠。一旦缓冲区中有空单元，生产者进程就向空单元中入写字符，并报告写的内容和位置。一旦缓冲区中有未读过的字符，消费者进程就从该单元中读出字符，并报告读取位置。生产者不能向同一单元中连续写两次以上相同的字符，消费者也不能从同一单元中连续读两次以上相同的字符。
1.2 代码的解释
1.2.1 ipc.h文件
首先，我们在文件夹下建立ipc.h的C程序的头文件。在该文件下，我们定义了消费者/生产者的共用的IPC函数的原型和变量。其中，我们重点关注down函数和up函数的作用，以及信号量的声明及其作用：
当进程希望释放内核信号量锁时，就调用up()函数；当进程希望获取内核信号量锁时，调用down()函数。此外，我们声明了key_t cons_key; key_t cmtx_key; int cons_sem; int cmtx_sem; int sem_val; int sem_flg; int shm_flg等信号量。
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);
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 cons_key;
key_t cmtx_key;
int cons_sem;
int cmtx_sem;
int sem_val;
int sem_flg;
int shm_flg;
1.2.2 ipc.c文件
在当前新建文件夹下建立ipc.c的C程序，该程序中定义了生产者/消费者共用的IPC函数；该文件中是ipc.h头文件里的具体实现。
ipc.c代码如下：
#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;
}
1.2.3 producer.c文件
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 = 8; // 缓冲区任给的长度
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; // 生产者互斥信号灯键值
cons_key = 301; // 消费者同步信号灯键值
cmtx_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;
// 获取消费者同步信号灯,引用标识存 cons_sem
cons_sem = set_sem(cons_key,sem_val,sem_flg);
// 生产者互斥信号灯初值为 1
sem_val = 1;
// 获取生产者互斥信号灯,引用标识存 pmtx_sem
pmtx_sem = set_sem(pmtx_key,sem_val,sem_flg);
// 循环执行模拟生产者不断放产品
while(1)
{
// 如果缓冲区满则生产者阻塞
down(prod_sem);
// 如果另一生产者正在放产品,本生产者阻塞
down(pmtx_sem);
// 用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置
buff_ptr[*pput_ptr] = 'A' + *pput_ptr;
sleep(rate);
printf("%d producer put: %c to Buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
// 存放位置循环下移
*pput_ptr = (*pput_ptr+1) % buff_num;
// 唤醒阻塞的生产者
up(pmtx_sem);
// 唤醒阻塞的消费者
up(cons_sem);
}
return EXIT_SUCCESS;
}
1.2.4 consumer.c文件
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 = 8; // 缓冲区任给的长度
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; // 生产者互斥信号灯键值
cons_key = 301; // 消费者同步信号灯键值
cmtx_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;
// 获取消费者同步信号灯,引用标识存 cons_sem
cons_sem = set_sem(cons_key,sem_val,sem_flg);
// 消费者互斥信号灯初值为 1
sem_val = 1;
// 获取消费者互斥信号灯,引用标识存 pmtx_sem
cmtx_sem = set_sem(cmtx_key,sem_val,sem_flg);
// 循环执行模拟消费者不断取产品
while(1)
{
// 如果无产品消费者阻塞
down(cons_sem);
// 如果另一消费者正在取产品,本消费者阻塞
down(cmtx_sem);
// 用读一字符的形式模拟消费者取产品,报告本进程号和获取的字符及读取的位置
sleep(rate);
printf("%d consumer get: %c from Buffer[%d]\n", getpid(),
buff_ptr[*cget_ptr], *cget_ptr);
// 读取位置循环下移
*cget_ptr = (*cget_ptr+1) % buff_num;
// 唤醒阻塞的消费者
up(cmtx_sem);
// 唤醒阻塞的生产者
up(prod_sem);
}
return EXIT_SUCCESS;
}
1.3 代码的运行及结果
在上述代码编写完成之后，我们继续编写相应的makefile文件以及执行代码。在虚拟机上进行运行之后，我们分别在当前终端窗体下建立启动执行速率为1秒的生产者进程、启动执行速率为3秒的生产者进程、启动执行速率为2秒的消费者进程、启动执行速率为4秒的消费者进程，运行结果分别如下：
1.3.1 生产者进程
建立启动执行速率为1秒的生产者进程：
可以看到：由于缓冲区已满，该生产者进程被阻塞。
建立启动执行速率为3秒的生产者进程：
可以看到，该生产者由于缓冲区已满，而被立即阻塞。
1.3.2 消费者进程
建立启动执行速率为2秒的消费者进程：
建立启动执行速率为4秒的消费者进程：
可以看到，由于缓冲区里的内容正在被消费者消费，此时原本被阻塞的生产者进程不再被阻塞，能够运行。
1.3.3 进程阻塞与打断实验
可以看到，在缓冲区已满后，两个生产者进程都被阻塞；此后，我们建立了相应的消费者进程。由于缓冲区里的内容正在被消费者消费，此时原本被阻塞的生产者进程不再被阻塞，能够运行。运行结果已经在1.3.1 和1.3.2中给出。
接下来，我们需要对两个生产者进程以及消费者进程进行打断。
打断两个消费者进程之后的结果如下：
可以看到，在我们打断了两个生产者进程后，由于缓冲区已空，消费者进程被阻塞。
同理，我们打断两个消费者进程后，由于缓冲区已满，消费者进程也会被阻塞。
2 上机实验二
2.1 实验内容
假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍的IPC同步机制编程，实现该问题要求的功能。
2.2 问题分析
该问题主要涉及到操作系统中的进程见的同步与互斥的，可以看做是生产者消费者一类的问题。
三个抽烟者相当于三个不同的消费者，他们每次只会有一个抽烟者可以抽到烟，其余两个则需要等待。而在这里默认空间大小只有一个单元，即供应者每次放下两种材料后都会停下来等待直到有消费者使用了这两种材料，他才会继续放另两种材料。相当于说缓冲区的大小为1。为了方便起见，我们把要放的两种材料捆绑到一起，看成一个单位，分别用A、B、C表示，三个吸烟着分别用1,2,3号表示。
设置五个信号量分别为三个抽烟者对应的glue、tobacco、paper和与供应者相应的同步信号量表示缓存区为空的empty信号量。最后还有一个保证临界资源安全访问的互斥信号量mutex。
信号量的初始值如下：
empty=1;mutex=1;glue=0;paper=0;tobacco=0;
2.3 代码的编写
2.3.1 ipc.h文件
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);
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 tobacco_key;
key_t glue_key;
key_t paper_key;
int tobacco_sem;
int glue_sem;
int paper_sem;
//消费者有关的信号量
key_t empty_key;
key_t mutex_key;
int empty_sem;
int mutex_sem;
int sem_val;
int sem_flg;
int shm_flg;
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 tobacco_key;
key_t glue_key;
key_t paper_key;
int tobacco_sem;
int glue_sem;
int paper_sem;
//消费者有关的信号量
key_t empty_key;
key_t mutex_key;
int empty_sem;
int mutex_sem;
int sem_val;
int sem_flg;
int shm_flg;
2.3.2 ipc.c文件
ipc.c文件代码如下：
#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;
}
2.3.3 生产者代码producer.c
生产者代码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);
//信号量使用的变量
tobacco_key = 201; //生产者同步信号灯键值
glue_key = 202; //生产者互斥信号灯键值
paper_key=203; //生产者3的同步信号灯键值
empty_key = 301; //消费者同步信号灯键值
mutex_key = 302; //消费者互斥信号灯键值
sem_flg = IPC_CREAT | 0644;
//生产者同步信号灯初值设为缓冲区最大可用量
sem_val = buff_num;
//获取生产者同步信号灯,引用标识存 prod_sem
empty_sem = set_sem(empty_key,sem_val,sem_flg);
//消费者初始无产品可取,同步信号灯初值设为 0
sem_val = 0;
//获取消费者同步信号灯,引用标识存 cons_sem
paper_sem = set_sem(paper_key,sem_val,sem_flg);
glue_sem = set_sem(glue_key,sem_val,sem_flg);
tobacco_sem = set_sem(tobacco_key,sem_val,sem_flg);
//生产者互斥信号灯初值为 1
sem_val = 1;
//获取生产者互斥信号灯,引用标识存 pmtx_sem
mutex_sem = set_sem(mutex_key,sem_val,sem_flg);
int i=0;
//循环执行模拟生产者不断放产品
while(1){
int d;
//如果缓冲区满则生产者阻塞
down(empty_sem);
//如果另一生产者正在放产品,本生产者阻塞
down(mutex_sem);
//用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置
//buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;
sleep(rate);
d=(i++)%3;
printf("%d provider put: %d to Buffer[%d]\n",getpid(),d,*pput_ptr);
//存放位置循环下移
*pput_ptr = (*pput_ptr+1) % buff_num;
//唤醒阻塞的生产者
up(mutex_sem);
//唤醒阻塞的消费者
if(d==0)
up(paper_sem);
if(d==1)
up(glue_sem);
if(d==2)
up(tobacco_sem);
}
return EXIT_SUCCESS;
}
}
#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);
//信号量使用的变量
tobacco_key = 201; //生产者同步信号灯键值
glue_key = 202; //生产者互斥信号灯键值
paper_key=203; //生产者3的同步信号灯键值
empty_key = 301; //消费者同步信号灯键值
mutex_key = 302; //消费者互斥信号灯键值
sem_flg = IPC_CREAT | 0644;
//生产者同步信号灯初值设为缓冲区最大可用量
sem_val = buff_num;
//获取生产者同步信号灯,引用标识存 prod_sem
empty_sem = set_sem(empty_key,sem_val,sem_flg);
//消费者初始无产品可取,同步信号灯初值设为 0
sem_val = 0;
//获取消费者同步信号灯,引用标识存 cons_sem
paper_sem = set_sem(paper_key,sem_val,sem_flg);
glue_sem = set_sem(glue_key,sem_val,sem_flg);
tobacco_sem = set_sem(tobacco_key,sem_val,sem_flg);
//生产者互斥信号灯初值为 1
sem_val = 1;
//获取生产者互斥信号灯,引用标识存 pmtx_sem
mutex_sem = set_sem(mutex_key,sem_val,sem_flg);
int i=0;
//循环执行模拟生产者不断放产品
while(1){
int d;
//如果缓冲区满则生产者阻塞
down(empty_sem);
//如果另一生产者正在放产品,本生产者阻塞
down(mutex_sem);
//用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置
//buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;
sleep(rate);
d=(i++)%3;
printf("%d provider put: %d to Buffer[%d]\n",getpid(),d,*pput_ptr);
//存放位置循环下移
*pput_ptr = (*pput_ptr+1) % buff_num;
//唤醒阻塞的生产者
up(mutex_sem);
//唤醒阻塞的消费者
if(d==0)
up(paper_sem);
if(d==1)
up(glue_sem);
if(d==2)
up(tobacco_sem);
}
return EXIT_SUCCESS;
}
}
2.3.4 消费者进程代码consumer_glue.c
消费者进程代码consumer_glue.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);
//信号量使用的变量
tobacco_key = 201; //生产者同步信号灯键值
glue_key = 202; //生产者互斥信号灯键值
paper_key=203; //生产者3的同步信号灯键值
empty_key = 301; //消费者同步信号灯键值
mutex_key = 302; //消费者互斥信号灯键值
sem_flg = IPC_CREAT | 0644; //信号灯操作权限
//生产者同步信号灯初值设为缓冲区最大可用量
sem_val = buff_num;
//获取生产者同步信号灯,引用标识存 prod_sem
empty_sem = set_sem(empty_key,sem_val,sem_flg);
//消费者初始无产品可取,同步信号灯初值设为 0
sem_val = 0;
//获取消费者同步信号灯,引用标识存 cons_sem
glue_sem = set_sem(glue_key,sem_val,sem_flg);
while(1){
//如果无产品消费者阻塞
down(glue_sem);
//用读一字符的形式模拟消费者取产品,报告本进程号和
sleep(rate);
printf("%d 1号吸烟者 得到了: 烟草和纸 from Buffer[%d]\n",getpid(),*cget_ptr);
//读取位置循环下移
*cget_ptr = (*cget_ptr+1) % buff_num;
//唤醒阻塞的生产者
up(empty_sem);
}
return EXIT_SUCCESS;
}
2.3.5 消费者进程代码consumer_tobacco.c
消费者进程代码consumer_tobacco.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);
//信号量使用的变量
tobacco_key = 201; //生产者同步信号灯键值
glue_key = 202; //生产者互斥信号灯键值
paper_key=203; //生产者3的同步信号灯键值
empty_key = 301; //消费者同步信号灯键值
mutex_key = 302; //消费者互斥信号灯键值
sem_flg = IPC_CREAT | 0644; //信号灯操作权限
//生产者同步信号灯初值设为缓冲区最大可用量
sem_val = buff_num;
//获取生产者同步信号灯,引用标识存 prod_sem
empty_sem = set_sem(empty_key,sem_val,sem_flg);
//消费者初始无产品可取,同步信号灯初值设为 0
sem_val = 0;
//获取消费者同步信号灯,引用标识存 cons_sem
tobacco_sem = set_sem(tobacco_key,sem_val,sem_flg);
while(1){
//如果无产品消费者阻塞
down(tobacco_sem);
//用读一字符的形式模拟消费者取产品,报告本进程号和
sleep(rate);
printf("%d 2号吸烟者 得到了: 胶水和纸 from Buffer[%d]\n",getpid(),*cget_ptr);
//读取位置循环下移
*cget_ptr = (*cget_ptr+1) % buff_num;
//唤醒阻塞的生产者
up(empty_sem);
}
return EXIT_SUCCESS;
}
2.3.6 消费者进程代码consumer_paper.c
消费者进程代码consumer_paper.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);
//信号量使用的变量
tobacco_key = 201; //生产者同步信号灯键值
glue_key = 202; //生产者互斥信号灯键值
paper_key=203; //生产者3的同步信号灯键值
empty_key = 301; //消费者同步信号灯键值
mutex_key = 302; //消费者互斥信号灯键值
sem_flg = IPC_CREAT | 0644; //信号灯操作权限
//生产者同步信号灯初值设为缓冲区最大可用量
sem_val = buff_num;
//获取生产者同步信号灯,引用标识存 prod_sem
empty_sem = set_sem(empty_key,sem_val,sem_flg);
//消费者初始无产品可取,同步信号灯初值设为 0
sem_val = 0;
//获取消费者同步信号灯,引用标识存 cons_sem
paper_sem = set_sem(paper_key,sem_val,sem_flg);
while(1){
//如果无产品消费者阻塞
down(paper_sem);
//用读一字符的形式模拟消费者取产品,报告本进程号和
sleep(rate);
printf("%d 0号吸烟者 得到了: 烟草和胶水 from Buffer[%d]\n",getpid(),*cget_ptr);
//读取位置循环下移
*cget_ptr = (*cget_ptr+1) % buff_num;
//唤醒阻塞的生产者
up(empty_sem);
}
return EXIT_SUCCESS;
}
扫一扫
2886
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
