12.1 共享内存、信号量函数封装、多进程操作共享内存

 　　共享内存函数封装：

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include <sys/ipc.h>
#include <sys/sem.h>
#include "myipc_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) */
};

//@返回值 0 正确 其他错误
int sem_creat(int key, int *semid)
{
    int     ret = 0;
    //int     tmpsemid = 0;
    
    if (semid == NULL)
    {
        ret = SEMERR_PARAM;
        printf("func sem_creat() err:%d\n", ret);
        return ret;
    }
    ret = semget(key, 1, 0666| IPC_CREAT | IPC_EXCL); 
    if (ret == -1)
    {
            ret = errno;
            //perror("semget");
            if (errno == EEXIST) 
            {
                ret = SEMERR_EEXIST;
                printf("func sem_creat() 检测到信号量集已经存在:%d\n", ret);
                return ret;
            }
    }
    *semid = ret;
    
    ret = sem_setval(*semid, 1);
    if (ret != 0)
    {
        printf("func sem_setval() err:%d\n", ret);
        return ret;
    }
    ret = 0;
    return ret;
}   

int sem_open(int key, int *semid)
{
    int ret = 0;
    
    if (semid == NULL)
    {
        ret = SEMERR_PARAM;
        printf("func sem_open() err:%d\n", ret);
        return ret;
    }
    
    ret = semget(key, 0, 0); 
    if (ret == -1)
    {
            ret = errno;
            printf("func sem_open() 失败:%d\n", ret);
            return ret;    
    }
    *semid = ret;
    ret = 0;
    return ret;
}  

int sem_setval(int semid, int val)
{
    int ret = 0;
    union semun su;
    su.val = val;
    ret = semctl(semid, 0,  SETVAL, su);
    return ret;
}

/*
int sem_getval(int semid, int *val)
{
    int ret = 0;
    int tmpval;
    if (val == NULL)
    {
        ret = SEMERR_PARAM;
        printf("func sem_getval() err:%d\n", ret);
        return ret;
    }
    union semun su;
    tmpval = su.val ;
    ret = semctl(semid, 0, GETVAL, su);
    *val = tmpval  ;
    printf("val:%d\n", tmpval);
    return ret;
}
*/
int sem_getval(int semid, int *myval)
{
    int ret = 0;
    int val;
    union semun su;
    val = su.val ;
    //信号量 计数值
    ret = semctl(semid, 0, GETVAL, su);
    //printf("val:%d\n", val);
    
    *myval = ret;
    ret = 0;
    return ret;
}

//信号量p操作时候，需要传递好几个信息给linux内核
//所以linux内核定义了一个结构
//我要操作信号量集的下标 0
//我要执行什么操作 -1 +1
//我按照什么策略执行操作 0  UNDO NOWAITing
int sem_p(int semid)
{
    struct sembuf buf = {0, -1, 0};
    int ret = 0;
    ret = semop(semid, &buf, 1);
    return ret;
}

int sem_v(int semid)
{
    struct sembuf buf = {0, 1, 0};
    int ret = 0;
    ret = semop(semid, &buf, 1);
    return ret;
}

 

　　信号量函数封装：

#define    _OS_LINUX_

#if defined _OS_LINUX_
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <memory.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include "myipc_shm.h" 

#endif

int shmflag = 0;
int shmkey;

/***********************************************************************
  功能描述：    创建共享内存
  参数说明：    shmname  [in]  是共享内存名,系统中唯一标志
                shmsize  [in]  是要创建的共享内存的大小；
                shmhdl   [out] 共享内存的句柄.
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int IPC_CreatShm(char *shmseedfile, int shmsize, int *shmhdl)
{
    if(shmflag == 0)            //判断接口*享内存key是否已经存在
    {
        shmkey = ftok(shmseedfile, 'c');
        if (shmkey == -1)
        {
            perror("ftok");
            return -1;
        }
            
        shmflag = 1;
    }
    
    //创建共享内存
    *shmhdl = shmget(shmkey,shmsize,IPC_CREAT|0666);
    if (*shmhdl == -1)            //创建失败
        return -2;
    return 0;

}
/***********************************************************************
  功能描述：    关联共享内存
  参数说明：    shmhdl    [in]  共享的句柄
                mapaddr [out] 共享内存首地址
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int
IPC_MapShm(int  shmhdl, void  **mapaddr)
{
    void *tempptr = NULL;

    //连接共享内存
    tempptr = (void *)shmat(shmhdl,0,SHM_RND);
    if ((int)tempptr == -1)        //共享内存连接失败
        return -1;
    *mapaddr = tempptr;            //导出共享内存首指针

    return 0;
}
/***********************************************************************
  功能描述：    取消共享内存关联
  参数说明：    unmapaddr   [in] 共享内存首地址
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int IPC_UnMapShm(void *unmapaddr)
{
    int  rv;
    //取消连接共享内存 
    rv = shmdt((char *)unmapaddr);
    if (rv == -1)            //取消连接失败
        return -1;

    return 0;
}
/***********************************************************************
  功能描述：    删除共享内存
  参数说明：    shmhdl    [in]  共享的句柄
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int IPC_DelShm(int shmhdl)
{
    int  rv;
    //删除共享内存
    rv = shmctl(shmhdl,IPC_RMID,NULL);
    if(rv < 0)                //删除共享内存失败
        return -1;
    return 0;
}

 多进程操作共享内存：

#include <sys/types.h>
#include <unistd.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <signal.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>

#include "myipc_sem.h"
#include "myipc_shm.h"

int g_key = 0x3333;

void TestFunc(int loopnum)
{
    printf("loopnum:%d\n", loopnum);
    
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     sem_p(semid); //临界区开始
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d\n", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        sleep(2);
        
    sem_v(semid);  //临界区开始
    //
    printf("进程正常退出:%d\n", getpid());
}    

int main(void )
{
    int res;
    int procnum=10;
    int loopnum = 100;


    int  i=0,j = 0;

    printf("请输入要创建子进程的个数 : \n");
    scanf("%d", &procnum);

    printf("请输入让每个子进程测试多少次 :\n");
    scanf("%d", &loopnum);
    
    //共享内存创建
    int        ret = 0;
    int     shmhdl = 0;
    ret = IPC_CreatShm(".", sizeof(int), &shmhdl);
    if (ret != 0)
    {
        printf("func IPC_CreatShm() err:%d \n", ret);
        return ret;
    }
    
    
    //信号量的创建
     int      semid = 0;
    ret = sem_creat(g_key, &semid);
    if (ret != 0)
    {
        printf("func sem_creat() err:%d,重新按照open打开信号量 \n", ret);
        if (ret == SEMERR_EEXIST)
        {
            ret = sem_open(g_key, &semid);
            if (ret != 0)
            {
                printf("按照打开的方式，重新获取sem失败:%d \n", ret);
                return ret;
            }
        }
        else
        {
            return ret;
        }
        
    }
    
    int  val = 0;
    ret = sem_getval(semid, &val);
    if (ret != 0 )
    {
        printf("func sem_getval() err:%d \n", ret);
        return ret;
    }
    printf("sem val:%d\n", val);
    getchar();

    pid_t pid;

    for (i=0; i<procnum; i++)
    {
        pid = fork();  //有几个fork就有几个子进程
        if (pid == 0)
        {
            for (j=0; j<loopnum; j ++)
            {
                TestFunc(j);
            }
            exit(0);
        }

    }

    //让所有的子进程退出 父进程才退出

/*
      while(1)
      {
          res = wait(NULL);//
          if(res==-1)
          {
              if(errno==EINTR) //若阻塞中有别的信号中断
              {
                  continue;
              }
              break;
          }
      }
      */
      
      int mypid = 0;
      while ( (mypid= waitpid(-1, NULL, WNOHANG)) > 0)
      {
          //printf("退出的子进程pid为:mypid:%d \n", mypid);
          ;
      }


    printf("父进程退出 hello...\n");
    return 0;
}