第三十三章 System V共享内存与信号量综合

2022-09-20 08:47:07

用信号量解决生产者、消费者问题

实现shmfifo

ip.h

#ifndef _IPC_H

#define _IPC_H

#include <unistd.h>

#include <sys/types.h>

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/ipc.h>

#include <sys/sem.h>

union semun {

    int              val;    /* Value for SETVAL */

    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */

    unsigned short  *array;  /* Array for GETALL, SETALL */

    struct seminfo  *__buf;  /* Buffer for IPC_INFO

                                (Linux-specific) */

};

#define ERR_EXIT(m)         \

    do                      \

    {                       \

        perror(m);          \

        exit(EXIT_FAILURE); \

    } while (0)

int sem_create(key_t key);

int sem_del(int semid);

int sem_open(key_t key);

int sem_setval(int semid, int val);

int sem_getval(int semid, int val);

int sem_p(int semid);

int sem_v(int semid);

#endif // !_IPC_H

ip.c

#include "ipc.h"

int sem_create(key_t key)

{

    int semid;

    semid = semget(key, 1, IPC_CREAT|IPC_EXCL| 0666);

    if(semid == -1)

        ERR_EXIT("semget");

    return semid;

}

int sem_open(key_t key)

{

    int semid;

    semid = semget(key, 0, 0);

    if(semid == -1)

        ERR_EXIT("semget");

    return semid;

}

int sem_setval(int semid, int val)

{

    union semun su;

    su.val = val;

    int ret;

    ret = semctl(semid, 0, SETVAL, su);

    if(ret == -1)

        ERR_EXIT("semctl");

    return 0;

}

int sem_del(int semid)

{

    int ret;

    ret = semctl(semid, 0, IPC_RMID, 0);

    if(ret == -1)

        ERR_EXIT("semctl");

    return 0;

}

int sem_getval(int semid, int val)

{

    int ret;

    ret = semctl(semid, 0, GETVAL, 0);

    if(ret == -1)

        ERR_EXIT("semctl getval");

    return ret;

}

int sem_p(int semid)

{

    struct sembuf sops = {0, -1, 0};

    int ret;

    ret = semop(semid, &sops, 1);

    if(ret == -1)

        ERR_EXIT("semop");

    return 0;

}

int sem_v(int semid)

{

    struct sembuf sops = {0, 1, 0};

    int ret;

    ret = semop(semid, &sops, 1);

    if(ret == -1)

        ERR_EXIT("semop");

    return 0;

}

shmfifo.h

#ifndef SHM_FIFO_H

#define SHM_FIFO_H

#include "ipc.h"

typedef struct shmfifo shmfifo_t;

typedef struct shmhead shmhead_t;

struct shmhead

{

    unsigned int blksize;       //块大小

    unsigned int blocks;        //总块数

    unsigned int rd_index;      //读索引

    unsigned int wr_index;      //写索引

};

struct shmfifo

{

    shmhead_t *p_shm;       //共享内存头部指针

    char *p_payload;        //有效负载的起始地址

    int shmid;              //共享内存ID

    int sem_mutex;          //用来互斥用的信号量

    int sem_full;           //用来控制共享内存是否满的信号量

    int sem_empty;          //用来控制共享内存是否空的信号量

};

shmfifo_t* shmfifo_init(int key, int blksize, int blocks);

void shmfifo_put(shmfifo_t* fifo, const void* buf);

void shmfifo_get(shmfifo_t* fifo, void* buf);

void shmfifo_destory(shmfifo_t *fifo);

#endif // !SHM_FIFO_H

shmfifo.c

#include "shmfifo.h"

#include <assert.h>

#include <sys/ipc.h>

#include <sys/shm.h>

shmfifo_t* shmfifo_init(int key, int blksize, int blocks)

{

    shmfifo_t *fifo = (shmfifo_t*)malloc(sizeof(shmfifo_t));

    assert(fifo != NULL);

    memset(fifo, 0, sizeof(shmfifo_t));

    int shmid;

    //假设共享内存已存在，直接打开

    shmid = shmget(key, 0, 0);

    int size = sizeof(shmhead_t) + blksize*blocks;

    if(shmid == -1)

    {

        //打开失败，表示之前没有创建共享内存

        fifo->shmid = shmget(key, size, IPC_CREAT|0666);

        if(fifo->shmid == -1)

            ERR_EXIT("shmget");

        //把共享内存区对象映射到调用进程的地址空间

        fifo->p_shm = (shmhead_t*)shmat(fifo->shmid, NULL, 0);

        if(fifo->p_shm == (shmhead_t*)-1)

            ERR_EXIT("shmat");

        //初始化fifo这个结构

        fifo->p_payload = (char *)(fifo->p_shm + 1);

        fifo->p_shm->blksize = blksize;

        fifo->p_shm->blocks = blocks;

        fifo->p_shm->rd_index = 0;

        fifo->p_shm->wr_index = 0;

        //创建信号量

        fifo->sem_mutex = sem_create(key);

        fifo->sem_full = sem_create(key+1);

        fifo->sem_empty = sem_create(key+2);

        //设置信号量初始值

        sem_setval(fifo->sem_mutex, 1);

        sem_setval(fifo->sem_full, blocks);

        sem_setval(fifo->sem_empty, 0);

    }

    else

    {

        //打开成功，共享内存和信号量已经存在

        //共享内存和信号量使用的同一个key;共享内存之间或信号量之间不能用一个key

        fifo->shmid = shmid;

        fifo->p_shm = shmat(fifo->shmid, NULL, 0);

        if(fifo->p_shm == (shmhead_t*)-1)

            ERR_EXIT("shmat");

        fifo->p_payload = (char *)fifo->p_shm+1;

        fifo->sem_mutex = sem_open(key);

        fifo->sem_full = sem_open(key+1);

        fifo->sem_empty = sem_open(key+2);

    }

    return fifo;

}

void shmfifo_put(shmfifo_t* fifo, const void* buf)

{

    //对信号量sem_full进行P操作；（sem_full = blocks）

    //sem_full--

    //若sem_full减1后仍大于或等于0，则进程继续执行

    //若sem_full减1后小于0，则该进程被阻塞后放入等待该信号量的等待队列中，然后转进程调度

    sem_p(fifo->sem_full);

    //  >=0

    //进程对信号量sem_mutex进行P操作，其它写进程将阻塞

    sem_p(fifo->sem_mutex);

    //将buf拷贝到共享内存中

    memcpy(fifo->p_payload + fifo->p_shm->blksize*fifo->p_shm->wr_index, buf, fifo->p_shm->blksize);

    //更新写的下标

    fifo->p_shm->wr_index = (fifo->p_shm->wr_index+1) % fifo->p_shm->blksize;

    //进程对信号量sem_mutex进行V操作，其他写进程可以执行

    sem_v(fifo->sem_mutex);

    //对共享内存进行V操作;

    //sem_empty ++

    //若加1后结果大于0，则进程继续执行；

    //若相加后结果小于或等于0，则从该信号的等待队列中释放一个等待进程，然后再返回原进程继续执行或转进程调度。

    sem_v(fifo->sem_empty);

}

void shmfifo_get(shmfifo_t* fifo, void* buf)

{

    //对信号量sem_empty进行P操作；（sem_full = 0）

    //sem_empty--

    //若sem_empty减1后仍大于或等于0，则进程继续执行

    //若sem_empty减1后小于0，则该进程被阻塞后放入等待该信号量的等待队列中，然后转进程调度

    sem_p(fifo->sem_empty);

    //  >=0

    //进程对信号量sem_mutex进行P操作，其它读进程将阻塞

    sem_p(fifo->sem_mutex);

    //将共享内存拷贝到buf中

    memcpy( buf, fifo->p_payload + fifo->p_shm->blksize*fifo->p_shm->rd_index, fifo->p_shm->blksize);

    //更新读的下标

    fifo->p_shm->rd_index = (fifo->p_shm->rd_index+1) % fifo->p_shm->blksize;

    //进程对信号量sem_mutex进行V操作，其他写进程可以执行

    sem_v(fifo->sem_mutex);

    //对共享内存进行V操作;

    //sem_full ++

    //若加1后结果大于0，则进程继续执行；

    //若相加后结果小于或等于0，则从该信号的等待队列中释放一个等待进程，然后再返回原进程继续执行或转进程调度。

    sem_v(fifo->sem_full);

}

void shmfifo_destory(shmfifo_t *fifo)

{

    sem_del(fifo->sem_mutex);

    sem_del(fifo->sem_full);

    sem_del(fifo->sem_empty);

    shmdt(fifo->p_shm);

    shmctl(fifo->shmid, IPC_RMID, NULL);

    free(fifo);

}

shmfifo_send.c

#include "shmfifo.h"

typedef struct stu

{

    int name[32];

    int age;

}STU;

int main(void)

{

    shmfifo_t *fifo = shmfifo_init(1234, sizeof(STU), 3);

    STU s;

    memset(&s, 9, sizeof(STU));

    s.name[0] = 'A';

    int i;

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

    {

        s.age = 20 + i;

        shmfifo_put(fifo,&s);

        s.name[0] = s.name[0] + 1;

        printf("send ok\n");

    }

    return 0;

}

shmfifo_recv.c

#include "shmfifo.h"

typedef struct stu

{

    int name[32];

    int age;

}STU;

int main(void)

{

    shmfifo_t *fifo = shmfifo_init(1234, sizeof(STU), 3);

    STU s;

    memset(&s, 9, sizeof(STU));

    int i;

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

    {

        s.age = 20 + i;

        shmfifo_get(fifo,&s);

        printf("name = %s age = %d\n",s.name, s.age);

    }

    return 0;

}

shmfifo_free

#include "shmfifo.h"

typedef struct stu

{

    int name[32];

    int age;

}STU;

int main(void)

{

    shmfifo_t *fifo = shmfifo_init(1234, sizeof(STU), 3);

    shmfifo_destory(fifo);

    return 0;

}

Makefile

.PHONY:clean all

CC=gcc

CFLAGS=-Wall -g 

BIN = shmfifo_recv shmfifo_send shmfifo_free

OBJS1 = shmfifo_recv.o shmfifo.o ipc.o

OBJS2 = shmfifo_send.o shmfifo.o ipc.o

OBJS3 = shmfifo_free.o shmfifo.o ipc.o

all:$(BIN)

%.o:%.c

	$(CC) $(CFLAGS) -c $< -o $@

shmfifo_recv: ${OBJS1}

	$(CC) $(CFLAGS) $^ -o $@

shmfifo_send: ${OBJS2}

	$(CC) $(CFLAGS) $^ -o $@

shmfifo_free: ${OBJS3}

	$(CC) $(CFLAGS) $^ -o $@

clean:

	rm -rf *.o $(BIN)

码农公寓

用信号量解决生产者、消费者问题

实现shmfifo

相关文章