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

    进程间的通信方式我们都熟悉，管道（命名管道）、信号（signal）、共享内存、消息队列、套接字（socket），关于信号量个人认为应该归为进程间的同步机制里。
    下面我们就说说共享内存的通信方式。 它是IPC中最快的。一旦内存区映射到共享它的进程的地址空间，这些进程间数据的传递就不在涉及内核。但是存取数据的时候需要保持同步. 关于共享内存权威的参考资料为《unix网络编程卷2》. 在前面我们讲解了mmap的内核机制，在posix v的共享内存的方式就是这个原理。system v也类似，只不过对接口进行了封装.
    我们先从posix v的方式开始说起，它常用的函数接口:
    open/shm_open  +  mmap  、munmap、msync、shm_unlink等.
    既然是open那么就会对应文件，当然并不是所有的文件都可以映射.这里支持的文件类型：
   1 .普通的磁盘文件 
   2. 设备文件（除去一些特殊的文件）
   3.内存文件 （例如tmpfs）
   4. 匿名映射 (主要用在具有亲缘关系的进程间)
     先说一下常用的匿名映射，直接open  /dev/zero 保证映射区域都初始化为0 的匿名映射。 还有可以直接用mmap来映射，而不用打开任何文件：

点击(此处)折叠或打开

1. mmap( NULL,size_of_map,PROT_READ|PROT_WRITE,MAP_SHARED | MAP_ANON, -1,0 );

这里提示一下mmap的函数原型：

点击(此处)折叠或打开

1. void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);

匿名映射主要区别是flags 里多了一个 MAP_ANON标志，和fd传递的为-1. 关于更多mmap的资料请自行查询.
    下面说一下一般mmap方式的共享内存需要注意的：
 映射的内存区域大小和文件大小，内存映射的大小都是页面的整数倍（PAGESIZE 4096默认） 比如文件大小为5000，映射了5000 ，那么可以访问2*PAGESIZE的内存区域，但是大于5000的内存写不会同步到文件里。这个内存可以访问的大小跟文件大小也是有关系的。映射的时候会自动检查底层的支持即文件的大小. 但是我们知道mmap的方式的优点就是可以动态的改变文件的大小，函数接口为ftruncate  和fstat. 具体用法参考unix网络编程卷2.

下面就简单总结下它的 特点：
1. 可以随时改变其大小  
操作函数接口：ftruncate  和fstat
2. 必须先创建打开一个文件为基础 ，这个文件可以是磁盘文件 或者内存文件比如tmpfs下的文件；如果共享内存的配置需要写入到磁盘 ，可以选择打开磁盘文件。如果在嵌入式里用一般会把flash一个文件作为映射 ，既然需要频繁的操作文件 和磁盘读写 所以建议还是用shm。  毕竟flash频繁读写影响寿命和容易出现坏块。

 而system v的方式不需要明确的open文件，但是函数操作接口比较多.
 函数接口： shmget、shmat、shmdt、shmctl等。
 shm方式有些限制：
  shmax  一个共享内存区的最大字节数     （具体系统不太一样）
 shmmnb  一个共享内存区的最小字节数   1
 shmmni 系统范围最大共享内存区标识数    128
 shmseg  每个进程附接的最大共享内存区数    32 
这些信息可以通过proc文件系统来查看。  cat   /proc/sys/kernel/shmmax 等.  具体查看映射的内存区 可以通过ipcs命令来查看和操作. 

我们也总结下它的特点：
    1.不需要创建和打开文件
    2. 如果是多进程间通信，需要统一 一个key标示 。动态生成的不一定一致。
    3.读写的速度高于mmap的方式
    4. 共享内存空间不能太大，毕竟直接占用内存空间.
不论哪种方式，都会涉及多进程间的通信、数据交互什么的，那么就必须保持互斥和同步，这里最常用的方式是采用信号量的方式.
信号量的接口：sem_init、sem_wait、sem_post.  由于用了信号量编译的时候会需要链接线程库 -lpthread.
下面就具体代码示例看看它们的具体用法：
posix v方式：
1. 初始化，之后进入循环不停的写，周期为1s。 

点击(此处)折叠或打开

1. #include <sys/mman.h>
   
2. #include <sys/types.h>
   
3. #include <fcntl.h>
   
4. #include <unistd.h>
   
5. #include <semaphore.h>
   
6. 
   
7. 
   
8. #define CLUSTER_SHARED_FILE "/tmp/cluster_share"
   
9. 
   
10. typedef struct{
    
11.     char name[4];
    
12.     int age;
    
13. }people;
    
14. 
    
15. struct stu {
    
16. 
    
17.     sem_t mutex;
    
18.     people s[10];
    
19. 
    
20. };
    
21. 
    
22. struct stu t;
    
23. 
    
24. main(int argc, char** argv) // map a normal file as shared mem:
    
25. {
    
26.     int fd,i;
    
27.     struct stu *p_map;
    
28.     char temp;
    
29.       
    
30.     fd=open(CLUSTER_SHARED_FILE,O_CREAT|O_RDWR|O_TRUNC,00777);
    
31.     lseek(fd,sizeof(t)-1,SEEK_SET);
    
32.     write(fd,"",1);
    
33.       
    
34.     p_map = (struct stu *) mmap( NULL,sizeof(t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 );
    
35.     close(fd);
    
36.     temp = 'a';
    
37.     sem_init(&p_map->mutex,1,1);
    
38.     int j=0;
    
39.     while(1)
    
40.     {
    
41.      j++;
    
42.      printf("j 1\n");
    
43.      sem_wait(&p_map->mutex);
    
44.      printf("j 2\n");
    
45.     for(i=1; i<10; i++)
    
46.     {
    
47.       // temp += 1;
    
48.     
    
49.         memcpy(p_map->s[i].name, &temp,2 );
    
50.         p_map->s[i].age = p_map->s[i].age +20+i+j;
    
51.     }
    
52.     printf("j 3\n");
    
53.     sem_post(&p_map->mutex);
    
54.     printf("j 4\n");
    
55.      sleep(1);
    
56.     }
    
57.     printf(" initialize over \n ");
    
58.     sleep(50);
    
59.     munmap( p_map, sizeof(t) );
    
60.     printf( "umap ok \n" );
    
61. }

2. 读取操作：

点击(此处)折叠或打开

1. #include <sys/mman.h>
   
2. #include <sys/types.h>
   
3. #include <fcntl.h>
   
4. #include <unistd.h>
   
5. 
   
6. #include <sys/sem.h>
   
7. 
   
8. #include <semaphore.h>
   
9. 
   
10. #define CLUSTER_SHARED_FILE "/tmp/cluster_share"
    
11. 
    
12. typedef struct{
    
13.     char name[4];
    
14.     int age;
    
15. }people;
    
16. 
    
17. struct stu {
    
18. 
    
19.     sem_t mutex;
    
20.     people s[10];
    
21. };
    
22. 
    
23. struct stu t;
    
24. 
    
25. main(int argc, char** argv) // map a normal file as shared mem:
    
26. {
    
27.     int fd,i;
    
28.     struct stu *p_map;
    
29.     char temp;
    
30.       
    
31.     fd=open(CLUSTER_SHARED_FILE,O_CREAT|O_RDWR,00777);
    
32.    // lseek(fd,sizeof(people)*5-1,SEEK_SET);
    
33.   // write(fd,"",1);
    
34.       
    
35.     p_map = (struct stu *) mmap( NULL,sizeof(t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 );
    
36.      close( fd );
    
37. 
    
38.      while(1)
    
39.     {
    
40.         sleep(1);
    
41.         printf("2.....s\n");
    
42.     sem_wait(&p_map->mutex);
    
43.     printf("2.....\n");
    
44.     for(i=0; i<10; i++)         
    
45.     {
    
46.         printf("name:%s,age:%d\n",p_map->s[i].name,p_map->s[i].age);
    
47.     
    
48.     }
    
49.         printf("2.....0\n");
    
50.         sem_post(&p_map->mutex);
    
51.         printf("2.......1");
    
52.     }
    
53.     munmap( p_map, sizeof(t));
    
54.     printf( "umap ok \n" );
    
55. }

至于并非的写操作，程序稍微修改一下就可以测试. 多并发没有问题.
system V的方式，虽然接口不太一样，但是也很类似。
1. 初始化

点击(此处)折叠或打开

1. #include <unistd.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <sys/shm.h>
   
6. #include <semaphore.h>
   
7. 
   
8. //#include "shmdata.h"
   
9. 
   
10. 
    
11. 
    
12. 
    
13. #define TEXT_SZ 2048
    
14.   
    
15. struct shared_use_st
    
16. {
    
17.     sem_t mutex;
    
18.     int written;//作为一个标志，非0：表示可读，0表示可写
    
19.     char text[TEXT_SZ];//记录写入和读取的文本
    
20.     int cnt;
    
21. };
    
22. 
    
23. 
    
24. int main()
    
25. {
    
26.     int running = 1;
    
27.     void *shm = NULL;
    
28.     struct shared_use_st *shared = NULL;
    
29.     char buffer[4096]="hello world";
    
30.     int shmid;
    
31.     int i=0;
    
32.     //创建共享内存
    
33. #if 0
    
34.     //删除共享内存
    
35.     if(shmctl(shmid, IPC_RMID, 0) == -1)
    
36.     {
    
37.         fprintf(stderr, "shmctl(IPC_RMID) failed\n");
    
38.         exit(EXIT_FAILURE);
    
39.     }
    
40. #endif
    
41.     shmid = shmget((key_t)12345, sizeof(struct shared_use_st), 0666|IPC_CREAT);
    
42.     if(shmid == -1)
    
43.     {
    
44.         fprintf(stderr, "shmget failed\n");
    
45.         exit(EXIT_FAILURE);
    
46.     }
    
47.     //将共享内存连接到当前进程的地址空间
    
48.     shm = shmat(shmid, (void*)0, 0);
    
49.     if(shm == (void*)-1)
    
50.     {
    
51.         fprintf(stderr, "shmat failed\n");
    
52.         exit(EXIT_FAILURE);
    
53.     }
    
54.     printf("Memory attached at %X\n", (int)shm);
    
55.     //设置共享内存
    
56.     shared = (struct shared_use_st*)shm;
    
57.     sem_init(&shared->mutex,1,1);
    
58.     
    
59.     while(running)//向共享内存中写数据
    
60.     {
    
61.         strncpy(shared->text, buffer, TEXT_SZ);
    
62. 
    
63.         sem_wait(&shared->mutex);
    
64.         //shared->cnt = 0;
    
65.         shared->cnt = shared->cnt +i;    
    
66.         sem_post(&shared->mutex);
    
67.         i++;
    
68.         shared->written = 1;
    
69. 
    
70.         sleep(1);
    
71.     }
    
72.     //把共享内存从当前进程中分离
    
73.     if(shmdt(shm) == -1)
    
74.     {
    
75.         fprintf(stderr, "shmdt failed\n");
    
76.         exit(EXIT_FAILURE);
    
77.     }
    
78.     sleep(2);
    
79.     exit(EXIT_SUCCESS);
    
80. }

2. 读取操作

点击(此处)折叠或打开

1. #include <unistd.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <sys/shm.h>
   
5. //#include "shmdata.h"
   
6. #include <semaphore.h>
   
7. 
   
8. 
   
9. 
   
10. 
    
11. #define TEXT_SZ 2048
    
12.   
    
13. struct shared_use_st
    
14. {
    
15.     sem_t mutex;
    
16.     int written;//作为一个标志，非0：表示可读，0表示可写
    
17.     char text[TEXT_SZ];//记录写入和读取的文本
    
18.     int cnt;
    
19. };
    
20. 
    
21. int main()
    
22. {
    
23.     int running = 1;//程序是否继续运行的标志
    
24.     void *shm = NULL;//分配的共享内存的原始首地址
    
25.     struct shared_use_st *shared;//指向shm
    
26.     int shmid;//共享内存标识符
    
27.     //创建共享内存
    
28.     shmid = shmget((key_t)12345, sizeof(struct shared_use_st), 0666);
    
29.     if(shmid == -1)
    
30.     {
    
31.         fprintf(stderr, "shmget failed\n");
    
32.         exit(EXIT_FAILURE);
    
33.     }
    
34.     //将共享内存连接到当前进程的地址空间
    
35.     shm = shmat(shmid, 0, 0);
    
36.     if(shm == (void*)-1)
    
37.     {
    
38.         fprintf(stderr, "shmat failed\n");
    
39.         exit(EXIT_FAILURE);
    
40.     }
    
41.     printf("\nMemory attached at %X\n", (int)shm);
    
42.     //设置共享内存
    
43.     shared = (struct shared_use_st*)shm;
    
44.    // shared->written = 0;
    
45.     while(running)//读取共享内存中的数据
    
46.     {
    
47. 
    
48.         sem_wait(&shared->mutex);
    
49.         printf("text:%s,cnt:%d\n",shared->text,shared->cnt);
    
50.         sem_post(&shared->mutex);
    
51.         sleep(1);
    
52. 
    
53. 
    
54.     }
    
55.     //把共享内存从当前进程中分离
    
56.     if(shmdt(shm) == -1)
    
57.     {
    
58.         fprintf(stderr, "shmdt failed\n");
    
59.         exit(EXIT_FAILURE);
    
60.     }
    
61. #if 0
    
62.     //删除共享内存
    
63.     if(shmctl(shmid, IPC_RMID, 0) == -1)
    
64.     {
    
65.         fprintf(stderr, "shmctl(IPC_RMID) failed\n");
    
66.         exit(EXIT_FAILURE);
    
67.     }
    
68. #endif
    
69.     exit(EXIT_SUCCESS);
    
70. }

整体的用法还算比较简单. 也很高效方便.