转载请注明出处:http://blog.csdn.net/suool/article/details/38515863

共享内存可以被描述成内存一个区域(段)的映射，这个区域可以被更多的进程所共享。这是IPC机制中最快的一种形式，因为它不需要中间环节，而是把信息直接从一个内存段映射到调用进程的地址空间。 一个段可以直接由一个进程创建，随后，可以有任意多的进程对其读和写。但是，一旦内存被共享之后，对共享内存的访问同步需要由其他 IPC 机制，例如信号量来实现。象所有的System V IPC 对象一样，Linux 对共享内存的存取是通过对访问键和访问权限的检查来控制的.

共享空间数据结构

<bits/shm.h>

/* 连接共享内存区的进程数的数据类型 */
typedef unsigned long int shmatt_t;

struct shmid_ds
{
    struct ipc_perm shm_perm;           /* operation permission struct */
    size_t shm_segsz;                   /* 共享存储段的最大字节数 */

    __time_t shm_atime;                 /* time of last shmat() */
    __time_t shm_dtime;                 /* time of last shmdt() */
    __time_t shm_ctime;                 /* time of last change by shmctl() */

    __pid_t shm_cpid;                   /* pid of creator */
    __pid_t shm_lpid;                   /* pid of last shmop */

    shmatt_t shm_nattch;                /* 连接共享内存区的进程数 */

//保留字段
#if __WORDSIZE == 32
    unsigned long int __unused1;
	unsigned long int __unused2;
	unsigned long int __unused3;
#endif
    unsigned long int __unused4;
    unsigned long int __unused5;
};

同时在使用共享内存进行数据存取的时候,为了避免出现读取交叉等错误,常常需要使用二元信号量来同步两个进程实现对共享内存的读取操作.

同时对于共享内存有一定的系统限制:

#include <bits/shm.h>
struct  shminfo
{
    unsigned long int shmmax;	//一个共享内存区的最大字节数
    unsigned long int shmmin;	//一个共享内存区的最小字节数
    unsigned long int shmmni;	//系统范围内的共享内存区对象的最大个数
    unsigned long int shmseg;	//每个进程连接的最大共享内存区的数目
    unsigned long int shmall;	//系统范围内的共享内存区的最大页数
    unsigned long int __unused1;
    unsigned long int __unused2;
    unsigned long int __unused3;
    unsigned long int __unused4;
};

[root@idcserver program]# sysctl -a | grep shm
...
kernel.shmmni = 4096			//系统范围内的共享内存区对象的最大个数
kernel.shmall = 4294967296		//系统范围内的共享内存区的最大页数
kernel.shmmax = 68719476736		//一个共享内存区的最大字节数

[root@idcserver program]#echo "kernel.shmmni= 1000" >>/etc/sysctl.conf
[root@idcserver program]#sysctl -p
[root@idcserver program]#sysctl -a |grep shm
kernel.shmmni = 1000
kernel.shmall = 4294967296
kernel.shmmax = 68719476736

共享内存的处理过程

某个进程第一次访问共享虚拟内存时将产生缺页异常。这时，Linux找出描述该内存的 vm_area_struct 结构，该结构中包含用来处理这种共享虚拟内存段的处理函数地址。共享内存缺页异常处理代码对shmid_ds 的页表项表进行搜索，以便查看是否存在该共享虚拟内存的页表项。如果没有，系统将分配一个物理页并建立页表项，该页表项加入 shmid_ds 结构的同时也添加到进程的页表中。这就意味着当下一个进程试图访问这页内存时出现缺页异常，共享内存的缺页异常处理代码则把新创建的物理页给这个进程。因此说，第一个进程对共享内存的存取引起创建新的物理页面，而其它进程对共享内存的存取引起把那个页加添加到它们的地址空间。

当某个进程不再共享其虚拟内存时，利用系统调用将共享段从自己的虚拟地址区域中移去，并更新进程页表。当最后一个进程释放了共享段之后，系统将释放给共享段所分配的物理页。

当共享的虚拟内存没有被锁定到物理内存时，共享内存也可能会被交换到交换区中。

System V共享内存区的创建和打开

下面是创建共享内存的shmget函数的接口以及说明：

#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
                     //成功返回共享内存标识符，失败返回-1

shmget函数用于创建或打开一个共享内存区对象，shmget成功调用会返回一个共享内存区的标识符，供其它的共享内存区操作函数使用。

key：用于创建共享内存区的键值，这个在前面其他System IPC创建的时候已经讨论过了，System IPC都有一个key，作为IPC的外部标识符，创建成功后返回的描述符作为IPC的内部标识符使用。key的主要目的就是使不同进程在同一IPC汇合。key具体说可以有三种方式生成：

• 不同的进程约定好的一个值；
• 通过相同的路径名和项目ID，调用ftok()函数，生成一个键；
• 还可以设置为IPC_PRIVATE，这样就会创建一个新的，唯一的IPC对象；然后将返回的描述符通过某种方式传递给其他进程；

size：指定创建共享内存区的大小，单位是字节。如果实际操作为创建一个共享内存区时，必须指定一个非0值，如果实际操作是访问一个已存在的共享内存区，那么size应为0。

shmflg：指定创建或打开消息队列的标志和读写权限（ipc_perm中的mode成员）。我们知道System V IPC定义了自己的操作标志和权限设置标志，而且都是通过该参数传递，这和open函数存在差别，open函数第三个参数mode用于传递文件的权限标志。System V IPC的操作标志包含：IPC_CREAT，IPC_EXCL。读写权限如下图：

图1 System V共享内存区的读写权限标志

System V共享内存区在创建后，该size大小的内存区会被初始化为0，这和POSIX共享内存不同，POSIX标准并没有规定新创建的POSIX共享内存区的初始内容。

System V共享内存区的连接和断接

通过shmctl创建或打开共享内存区对象后，并没有将该共享内存区映射到调用进程的地址空间中，所以无法访问该共享内存区，需要通过shmat函数，将该共享内存区连接到调用进程的地址空间中，才能进行访问，当该进程完成对该共享内存区的访问后，可以调用shmdt断接这个共享内存区，当然进程结束后会自动断接所有连接的共享内存区。下面是shmat和shmdt函数的接口以及说明：

#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
                        //成功返回映射区的起始地址，失败返回-1
int shmdt(const void *shmaddr);
                        //成功返回0，失败返回-1

shmat用于将一个共享内存区连接到调用进程的地址空间中。

shmid：打开的System V共享内存对象的标识符；

shmaddr和shmflg参数共同决定了共享内存区连接到调用进程的具体地址，规则如下：

• shmaddr为空指针：连接的地址由系统内核决定，这是推荐的方法，具有可移植性。
• shmaddr非空：此时还要根据shmflg参数是否指定SHM_RND标志进行判断：
  • 没有指定SHM_RND：共享内存区连接到调用进程的shmaddr指定的地址；
  • 指定SHM_RND：共享内存区连接到shmaddr指定的地址向下舍入SHMLBA的位置。

shmflg：除了上面说的SHM_RND外，还有可以指定SHM_RDONLY标志，限定只读访问。一般该标志置为0。

shmdt用于将一个共享内存区从该进程内断接，当一个进程终止时，它连接的所有共享内存区会自动断接。

System V共享内存区的控制操作

shmctl函数可以对共享内存区进行多种控制操作，下面是shmctl函数的接口以及说明：

#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
                     //成功返回0，失败返回-1

shmid：共享内存区的标识符。

cmd：对共享内存区控制操作的命令，Open Group 的SUS定义了一下三个操作命令：

• IPC_SET：按第三个参数buf所指定的内容，设置共享内存区的操作权限字段的：shm_perm.uid，shm_perm.gid和shm_perm.mode。此命令只能由以下进程执行：有效用户ID等于shm_perm.uid或shm_perm.cuid，以及有超级用户权限的进程。
• IPC_STAT：获取共享内存区的shmid_ds结构，存放到传入的第三个参数中。
• IPC_RMID：从系统内核中删除该共享内存区。因为每个共享内存区有一个连接数据的计数，除非连接该共享内存区的最后一个进程断接或终止，否则该共享内存区不会被实际删除。这和其他的System V IPC，例如System V消息队列的删除差别很大，倒是和POSIX IPC的xxx_unlink删除操作很相识。调用该命令后，该共享内存区标识符不能再继续被连接。此命令也只能由以下进程执行：有效用户ID等于shm_perm.uid或shm_perm.cuid，以及有超级用户权限的进程。

在Linux中还定义了其他的控制命令，如：IPC_INFO，SHM_INFO，SHM_LOCK，SHM_UNLOCK等，具体可以参考Linux手册。

#include <iostream>
#include <cstring>
#include <errno.h>

#include <unistd.h>
#include <fcntl.h>
#include <sys/shm.h>

using namespace std;

#define PATH_NAME "/tmp/shm"

int main()
{
    int fd;

    if ((fd = open(PATH_NAME, O_CREAT, 0666)) < 0)
    {
        cout<<"open file "<<PATH_NAME<<"failed.";
        cout<<strerror(errno)<<endl;
        return -1;
    }

    close(fd);

    key_t key = ftok(PATH_NAME, 0);

    int shmID;
    
    if ((shmID = shmget(key, sizeof(int), IPC_CREAT | 0666)) < 0)
    {
        cout<<"shmget failed..."<<strerror(errno)<<endl;
        return -1;
    }

    shmid_ds shmInfo;
    shmctl(shmID, IPC_STAT, &shmInfo);

    cout<<"shm key:0x"<<hex<<key<<dec<<endl;
    cout<<"shm id:"<<shmID<<endl;
    cout<<"shm_segsz:"<<shmInfo.shm_segsz<<endl;
    cout<<"shm_nattch:"<<shmInfo.shm_nattch<<endl;

    return 0;
}

共享内存示例应用

此示例程序实现没有亲缘关系的两个进程之间通过共享内存通信,同时使用信号量保证两个进程的读写同步:即是发送方在写共享内存的时候,接收端不能读内存区,反之亦同 .

在代码中,使用共享内存传递数据,使用信号量同步读写端基本思路如下:

• 首先设置信号量初始为0,表示没有写入数据,不可读.
• 发送端在信号量位0的时候写数据到共享内存,并阻塞读进程,写入完成后,设置信号量位1,此时可以读数据,不能写数据.
• 接收端在信号量位1的时候读出内存区的数据并阻塞写入端,读出完成后,设置信号量的值位0,表示独处完成,可以再次写数据.
  

下面是编译和运行结果:

发送端:

接收端

代码如下:

发送:

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

#include <string.h>
int main(int argc,char *argv[])
{
    int running=1;
    int shid;
    int semid;
    int value;
    char *sharem=NULL;

    struct sembuf  sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_flg = SEM_UNDO;

    if((semid=semget((key_t)123456,1,0666|IPC_CREAT))==-1)  // 创建信号量
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }

    if (semctl(semid, 0, SETVAL, 0) == -1)         // 设置初始值位0
    {
        printf("sem init error");
        if(semctl(semid,0,IPC_RMID,0)!=0)
        {
            perror("semctl");
            exit(EXIT_FAILURE);
        }
        exit(EXIT_FAILURE);	
    }
    shid=shmget((key_t)654321,(size_t)2048,0600|IPC_CREAT);    // 创建共享内存(读取id)
    if(shid==-1)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }


    sharem=shmat(shid,NULL,0);           // 挂载共享内存到进程
    if(sharem==NULL)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    while(running)
    {
        if((value=http://www.mamicode.com/semctl( semid, 0, GETVAL ))==0)     // 读取为0时>
接受:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>

int main(int argc,char *argv[])
{
    int running=1;
    char *shm_p=NULL;
    int shmid;	
    int semid;
    int value;

    struct sembuf  sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_flg = SEM_UNDO;

    if((semid=semget((key_t)123456,1,0666|IPC_CREAT))==-1)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    shmid=shmget((key_t)654321,(size_t)2048,0600|IPC_CREAT);
    if(shmid==-1)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    shm_p=shmat(shmid,NULL,0);            // 挂接
    if(shm_p==NULL)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    while(running)
    {
        if((value=http://www.mamicode.com/semctl( semid, 0, GETVAL ))==1)>

转载请注明出处:http://blog.csdn.net/suool/article/details/38515863