进程间通信IPC之--共享内存

共享内存的代码范例：

/*server.c:向共享内存中写入People*/  
#include <stdio.h>  
#include <sys/types.h>  
#include <sys/ipc.h>  
#include <sys/sem.h>  
  
int main()  
{  
    struct People{  
        char name[10];  
        int age;  
    };  
      
    int semid;  
    int shmid;  
    key_t semkey;  
    key_t shmkey;  
    semkey=ftok("server.c",0);  
    shmkey=ftok("client.c",0);  
      
    /*创建共享内存和信号量的IPC*/  
    semid=semget(semkey,1,0666|IPC_CREAT);  
    if(semid==-1)  
    printf("creat sem is fail/n");  
    shmid=shmget(shmkey,1024,0666|IPC_CREAT);  
    if(shmid==-1)  
    printf("creat shm is fail/n");  
      
    /*设置信号量的初始值，就是资源个数*/  
    union semun{  
        int val;  
        struct semid_ds *buf;  
        ushort *array;  
    }sem_u;  
      
    sem_u.val=1;  
    semctl(semid,0,SETVAL,sem_u);  
      
    /*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/  
      
    struct People * addr;  
    addr=(struct People*)shmat(shmid,0,0);  
    if(addr==(struct People*)-1)  
    printf("shm shmat is fail/n");  
      
    /*信号量的P操作*/  
    void p()  
    {  
        struct sembuf sem_p;  
        sem_p.sem_num=0;  
        sem_p.sem_op=-1;  
        if(semop(semid,&sem_p,1)==-1)  
        printf("p operation is fail/n");          
    }  
  
    /*信号量的V操作*/  
    void v()  
    {  
        struct sembuf sem_v;  
        sem_v.sem_num=0;  
        sem_v.sem_op=1;  
        if(semop(semid,&sem_v,1)==-1)  
        printf("v operation is fail/n");  
    }  
      
    /*向共享内存写入数据*/  
    p();  
    strcpy((*addr).name,"xiaoming");  
/*注意：①此处只能给指针指向的地址直接赋值，不能在定义一个  struct People people_1;addr=&people_1;因为addr在addr=(struct People*)shmat(shmid,0,0);时,已经由系统自动分配了一个地址，这个地址与共享内存相关联，所以不能改变这个指针的指向，否则他将不指向共享内存，无法完成通信了。 
注意：②给字符数组赋值的方法。刚才太虎了。。*/  
    (*addr).age=10;  
    v();  
      
    /*将共享内存与当前进程断开*/  
    if(shmdt(addr)==-1)  
    printf("shmdt is fail/n");    
      
}  

/*client.c:从共享内存中读出People*/  
#include <stdio.h>  
#include <sys/types.h>  
#include <sys/ipc.h>  
#include <sys/sem.h>  
  
int main()  
{  
    int semid;  
    int shmid;  
    key_t semkey;  
    key_t shmkey;  
    semkey=ftok("server.c",0);  
    shmkey=ftok("client.c",0);  
      
    struct People{  
        char name[10];  
        int age;  
    };  
  
    /*读取共享内存和信号量的IPC*/    
    semid=semget(semkey,0,0666);  
    if(semid==-1)  
    printf("creat sem is fail/n");  
    shmid=shmget(shmkey,0,0666);  
    if(shmid==-1)  
    printf("creat shm is fail/n");  
      
    /*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/  
    struct People * addr;  
    addr=(struct People*)shmat(shmid,0,0);  
    if(addr==(struct People*)-1)  
    printf("shm shmat is fail/n");  
      
    /*信号量的P操作*/  
    void p()  
    {  
        struct sembuf sem_p;  
        sem_p.sem_num=0;  
        sem_p.sem_op=-1;  
        if(semop(semid,&sem_p,1)==-1)  
        printf("p operation is fail/n");          
    }  
      
    /*信号量的V操作*/  
    void v()  
    {  
        struct sembuf sem_v;  
        sem_v.sem_num=0;  
        sem_v.sem_op=1;  
        if(semop(semid,&sem_v,1)==-1)  
        printf("v operation is fail/n");  
    }  
      
    /*从共享内存读出数据*/  
    p();  
    printf("name:%s/n",addr->name);  
    printf("age:%d/n",addr->age);  
    v();  
      
    /*将共享内存与当前进程断开*/  
    if(shmdt(addr)==-1)  
    printf("shmdt is fail/n");  
      
    /*IPC必须显示删除。否则会一直留存在系统中*/  
    if(semctl(semid,0,IPC_RMID,0)==-1)  
    printf("semctl delete error/n");  
    if(shmctl(shmid,IPC_RMID,NULL)==-1)  
    printf("shmctl delete error/n");  
}  

这里是比较通俗的解析：

2.3.3 共享内存 
　　 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。 
　　 首先要用的函数是shmget，它获得一个共享存储标识符。 
　　　　 #include <sys/types.h> 
　　　　 #include <sys/ipc.h> 
　　　　 #include <sys/shm.h> 
　　　　 int shmget(key_t key, int size, int flag); 
　　 这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。 
　　 当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。 
　　 void *shmat(int shmid, void *addr, int flag); 
　　 shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。 
　　 使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。

　　 2.3.4 信号量 
　　 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作： 
　　 （1） 测试控制该资源的信号量。 
　　 （2） 若此信号量的值为正，则允许进行使用该资源。进程将进号量减1。 
　　 （3） 若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）。 
　　 （4） 当进程不再使用一个信号量控制的资源时，信号量值加1。如果此时有进程正在睡眠等待此信号量，则唤醒此进程。 
　　 维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件/usr/src/linux/include　/linux　/sem.h中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合，用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget，用以获得一个信号量ID。 
　　 #include <sys/types.h> 
　　 #include <sys/ipc.h> 
　　 #include <sys/sem.h> 
　　 int semget(key_t key, int nsems, int flag); 
　　 key是前面讲过的IPC结构的关键字，它将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。 
　　 semctl函数用来对信号量进行操作。 
　　 int semctl(int semid, int semnum, int cmd, union semun arg); 
　　 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。 
　　 semop函数自动执行信号量集合上的操作数组。 
　　 int semop(int semid, struct sembuf semoparray[], size_t nops); 
　　 semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。 
　　 下面，我们看一个具体的例子，它创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后我们清除信号量。在下面的代码中，函数ftok生成我们上文所说的唯一的IPC关键字。

#include <stdio.h> 
#include <sys/types.h> 
#include <sys/sem.h> 
#include <sys/ipc.h> 
void main() { 
key_t unique_key; /* 定义一个IPC关键字*/ 
int id; 
struct sembuf lock_it; 
union semun options; 
int i;

unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*/ 
/* 创建一个新的信号量集合*/ 
id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666); 
printf("semaphore id=%d/n", id); 
options.val = 1; /*设置变量值*/ 
semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/

/*打印出信号量的值*/ 
i = semctl(id, 0, GETVAL, 0); 
printf("value of semaphore at index 0 is %d/n", i);

/*下面重新设置信号量*/ 
lock_it.sem_num = 0; /*设置哪个信号量*/ 
lock_it.sem_op = -1; /*定义操作*/ 
lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/ 
if (semop(id, &lock_it, 1) == -1) { 
printf("can not lock semaphore./n"); 
exit(1); 
}

i = semctl(id, 0, GETVAL, 0); 
printf("value of semaphore at index 0 is %d/n", i);

/*清除信号量*/ 
semctl(id, 0, IPC_RMID, 0); 
}

文章转载自：http://blog.csdn.net/lanmanck/article/details/6100019