共享内存

        IPC （进程控制块）资源是独立与任何进程的，它可以被任何进程访问，但不是无条件的，是有一定的规则和条件

1        key_t  ftok(char *pathname,char proj )函数   将文件路径和项目ID转换为System V IPC key(根据pathname 所指向的文件/目录ID 转换成System V IPC函数所需使用的key)。注意，pathname指定的文件必须存在且可以访问。   若成功则返回key_t的值，否则返回-1.错误原因保存在errorn中

        key与三种IPC资源（信号量(semaphore)  消息队列(Message queue)  共享内存（shared memory segment））的关系，与每一种资源的关系都是key_id 的对应，类似与键值对应的对应方式，是一一对应的。除了key值为0时，以该key值创建的IPC资源只能被创建者以及建立关系的进程使用（表面上看就是该进程与其子进程访问，其他进程不可访问）。这种key值被成为private的key。IPC_PR_VALE是对应的宏

        eg：key_t key = ftok("/tmp/sysvipc",12);

2         获取或创建一个共享的内存资源

        函数原型：int shmget(key_t  key,int  size, int  shmflg) ;     shmget()用来取得参数key所关联的内存识别编号。key表示外部健的大小，size表示共享内存的大小，shmflg表示操作方式（获取/创建，权限掩码（eg：0666））。

        参数shmflg：IPC_CREAT 如果存在则直接获取共享内存资源，如果对应的IPC资源不存在，则创建  

                                  IPC _EXCL （单独使用时）如果存在则获取，不存在则报错

                                IPC_CREAT | IPC_EXCL 如果不存在则创建，如果存在则保存

        返回值：成功则返回内存识别代号（这一块内存的首地址），否则返回-1    

3      连接共享内存（在进程共享内存之间建立链接地址映射，使得进程内部的虚拟地址与进程外部IPC资源体系中的共享内存的物理地址产生关联，从而让进程能够通过操作内部的虚拟地址操作IPC资源中的共享内存。这个过程被成为进程对共享内存的attach）

        函数原型： void * shmat(int shmid,const void * shmaddr,int shmflg)

                        参数shamaddr   为0,内核自动选择一个地址

                                                        不为0,参数shmflg也没有指定SHM_RND标志，则以参数shmaddr为链接地址

                                                        不为0,但是参数shmflg设置了SHM_RND标志，则参数shmaddr会自动调整为SHMLBA的整数倍。                                                参数shmflg还可以有SHM_RDONLY标志，表示这个连接操作只是用来读取该共享内存

        返回值：若成功则返回已连接好的地址，否则返回-1,

4     断开映射关系（用来将先前用shmat()连接的（attach）好的共享内存脱离（detach）当前的进程）

        函数原型：int shmdt(const void * shmaddr);

        参数：shmaddr为先前shmat（）返回的共享内存的首地址

        返回值： 成功返回0,否则返回-1

5      共享内存的使用（控制共享内存的运作）

        函数原型： int shmctl(int shmid,int cmd ,struct shmid_ds *buf);

        参数：shmid为预处理的共享内存识别代码，参数cmd为欲控制的操作，有一下几种

                IPC_STAT  把共享内存的shmid_ds结构数据复制到buf

                IPC_SET   将参数buf所指向的shmid_ds结构中的shm_perm.uid   shm_perm.gid  shm_perm.mode 复制到共享内存的shmid_ds结构内

                IPC_RMID  删除共享内存和其数据结构

                SHM_LOCK  不让这个共享内存置换到swap

                 SHM_UNLOCK  允许这个共享内存置换到swap

               shmid_ds的结构体定义如下

                struct  shmid_ds

                {

                        struct  ipc_perm   shm_perm;  //所使用的结构ipc_perm定义请参考msgctl()

                        int  shm_segsz;          //共享内存大小（bytes）

                        time_t   shm_atime;  //最后一次附加这个共享内存的时间

                        time_t   shm_dtime;  // 最后一次分离这个共享内存的时间

                        time_t   shm_ctime;   //最后一次改变这个共享内存结构的时间

                        unsigned  short  shm_cpid;  //建立这个共享内存的识别码

                        unsigned  short   shm_lpid;  //最后一个操作这个共享内存的进程识别码

                        short   shm_nattch;    

                        unsigned   short   shm_npages;

                        unsigned   long    *shm_nages;

                        struct   shm_desc  *attaches;

                }            

                返回值：成功则返回0，失败返回-1;               

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int getShm(key_t key)
{
    int shmId;

    shmId = shmget(key,512,IPC_EXCL | 0666);
    if(shmId < 0)
    {
        printf("获取共享内存失败\n");
        return shmId;
    }

    return shmId;
}

int createShm(key_t key)
{
    int shmId;

    shmId = shmget(key,512,IPC_CREAT | IPC_EXCL | 0666);
    if(shmId < 0)
    {
        printf("创建共享内存失败\n");
        return shmId;
    }

    return shmId;
}

int testRead()
{
    key_t key = ftok("/home/lcg/.vimrc",12);
    pid_t pid;    
    int i,ret,shmId;
    char *shmAdd;

    ret = setvbuf(stdout,NULL,_IONBF,0);
    if(ret < 0)
    {
        printf("设置缓冲失败\n");
        return 0;
    }

    shmId = getShm(key);
    if(shmId < 0)
    {
        shmId = createShm(key);
    }

    printf("key = [%p] shmId = [%d]\n",key,shmId);
    shmAdd = (char *)shmat(shmId,NULL,0);
    printf("Address = [%p]\n",shmAdd);

    pid = fork();
    wait();
    if(0 == pid)
    {
        for(i = 0;i < 100;i++)
        {
            shmAdd[i] = 'A' + i%26;
            putchar(shmAdd[i]);

            if(i % 26 == 0)
            {
                putchar('\n');
            }
            sleep(1);

        }
    }else if(pid > 0)
    {
        for(i = 0;i < 100;i++)
        {
            getchar();
        }
    }

    return 0;
}

int testshmCtl()
{
    key_t key = ftok("/home/lcg/.vimrc",13);
    int shmId;
    char *buff;
    char *shmAdd;
    int i,ret;
    struct shmid_ds shmStatBuff;

    ret = setvbuf(stdout,NULL,_IONBF,0);
    if(ret < 0)
    {
        printf("修改缓冲失败\n");
        return -1;
    }

    shmId = getShm(key);
    if(shmId < 0)
    {
        shmId = createShm(key);
    }

    ret = shmctl(shmId,IPC_STAT,&shmStatBuff);//控制共享内存的运作
    if(ret < 0)
    {
        printf("获取共享内存失败\n");
        return -1;
    }

    shmAdd = shmat(shmId,NULL,0);
    if(shmAdd < 0)
    {
        printf("与共享内存建立链接失败\n");
        return -1;
    }

    printf("key = [%p] shmId = [%d] shmAdd = [%p]\n",key,shmId,shmAdd);

    printf("shm_segsz = [%d] shm_atime = [%d] shm_nattch = [%d] cpid = [%d] pid = [%d]\n",
            shmStatBuff.shm_segsz,shmStatBuff.shm_atime,shmStatBuff.shm_nattch,shmStatBuff.shm_cpid,getpid());


    shmctl(shmId,IPC_RMID,NULL);
    while(1)
    {
        sleep(1);
        printf("i am alive\n");
    }
    return 0;
}

int main(void)
{
//    testRead();
    testshmCtl();
    return 0;
}

注：这是本人是“处博客”，请海涵

                

                                

转载于:https://my.oschina.net/lcg521521/blog/347698