共享内存生产者消费者

ipc.h

#pragma once

#ifndef _ipc_h
#define _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<unistd.h>
#define BUFSZ 256
//建立或获取ipc 的一组函数的原型说明

int P_operation(int sem_id);
int V_operation(int sem_id);
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_sem(key_t sem_key,int sem_val,int sem_flag);
/*信号灯控制用的共同体*/
typedef union semuns
{
    int val;
} Sem_uns;
//生产消费者共享缓冲区即其有关的变量
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;     //IPC key标识
int prod_sem;       //生产者同步信号量

//消费者有关的信号量
key_t cons_key;     //IPC key标识
int cons_sem;       //消费者同步信号量
int sem_val;
int sem_flg;
int shm_flg;
/*互斥信号量*/
key_t mtx_key;      //IPC key标识
int mtx_sem;        //互斥信号量

#endif

 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;
}
/*
* 信号灯上的P/V 操作
* sem_id:信号灯数组标识符
* sem_num:信号灯数组下标
* buf:操作信号灯的结构
*/
/*请求 P操作*/
int P_operation(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;
}
/*释放 V操作*/
int V_operation(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 信号灯数组的存取权限
*/
/*实现过程:*建立信号灯->设置信号灯初值->返回ID*/
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;
}

 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;//生产者同步信号灯键值
    mtx_key = 202;//互斥信号灯键值
    cons_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;
    //获取消费者同步信号灯，引用标识存cons_sem
    cons_sem = set_sem(cons_key,sem_val,sem_flg);
    //生产者互斥信号灯初值为1
    sem_val = 1;
    //获取互斥信号灯，引用标识存mtx_sem
    mtx_sem = set_sem(mtx_key,sem_val,sem_flg);
    //循环执行模拟生产者不断放产品
    while(1)
    {
        //如果缓冲区满则生产者阻塞
        P_operation(prod_sem);
        //如果有进程进入，本生产者阻塞
        P_operation(mtx_sem);
        //用写一字符的形式模拟生产者放产品，报告本进程号和放入的字符及存放的位置
        buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;
        //挂起rate秒
        //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;
        //唤醒阻塞的进程
        V_operation(mtx_sem);
        //唤醒阻塞的消费者
        V_operation(cons_sem);
    }
    return EXIT_SUCCESS;
}

 consumer

#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);
    mtx_key = 202; //互斥信号灯键值
    //生产者同步信号灯初值设为缓冲区最大可用量
    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;
    //获取消费者同步信号灯，引用标识存cons_sem
    cons_sem = set_sem(cons_key,sem_val,sem_flg);
    //消费者互斥信号灯初值为1
    sem_val = 1;
    //获取互斥信号灯，引用标识存mtx_sem
    mtx_sem = set_sem(mtx_key,sem_val,sem_flg);
    //循环执行模拟消费者不断取产品
    while(1){
        //如果无产品消费者阻塞
        P_operation(cons_sem);
        //如果有进程进入,本消费者阻塞
        P_operation(mtx_sem);
        //用读一字符的形式模拟消费者取产品，报告本进程号和获取的字符及读取的位置
       // sleep(rate);
        printf("%d consumer get: %c fromBuffer[%d]\n",getpid(),buff_ptr[*cget_ptr],*cget_ptr);
        //读取位置循环下移
        *cget_ptr = (*cget_ptr+1) % buff_num;
        //唤醒阻塞的进程
        V_operation(mtx_sem);
        //唤醒阻塞的生产者
        V_operation(prod_sem);
    }
    return EXIT_SUCCESS;
}

 

转载于:https://www.cnblogs.com/kangbry/p/4072645.html