TAG

RSS订阅

收藏本站

设为首页

当前位置:主页 > 移动开发 > 安卓开发 >

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

发布时间:2016-08-21 11:45 类别:安卓开发

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



进程间的通信方式我们都熟悉,管道(命名管道)、信号(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
  2. #include
  3. #include
  4. #include
  5. #include


  6. #define CLUSTER_SHARED_FILE "/tmp/cluster_share"

  7. typedef struct{
  8. char name[4];
  9. int age;
  10. }people;

  11. struct stu {

  12. sem_t mutex;
  13. people s[10];

  14. };

  15. struct stu t;

  16. main(int argc, char** argv) // map a normal file as shared mem:
  17. {
  18. int fd,i;
  19. struct stu *p_map;
  20. char temp;

  21. fd=open(CLUSTER_SHARED_FILE,O_CREAT|O_RDWR|O_TRUNC,00777);
  22. lseek(fd,sizeof(t)-1,SEEK_SET);
  23. write(fd,"",1);

  24. p_map = (struct stu *) mmap( NULL,sizeof(t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 );
  25. close(fd);
  26. temp = 'a';
  27. sem_init(&p_map->mutex,1,1);
  28. int j=0;
  29. while(1)
  30. {
  31. j++;
  32. printf("j 1\n");
  33. sem_wait(&p_map->mutex);
  34. printf("j 2\n");
  35. for(i=1; i<10; i++)
  36. {
  37. // temp += 1;

  38. memcpy(p_map->s[i].name, &temp,2 );
  39. p_map->s[i].age = p_map->s[i].age +20+i+j;
  40. }
  41. printf("j 3\n");
  42. sem_post(&p_map->mutex);
  43. printf("j 4\n");
  44. sleep(1);
  45. }
  46. printf(" initialize over \n ");
  47. sleep(50);
  48. munmap( p_map, sizeof(t) );
  49. printf( "umap ok \n" );
  50. }
2. 读取操作:
  1. #include
  2. #include
  3. #include
  4. #include

  5. #include

  6. #include

  7. #define CLUSTER_SHARED_FILE "/tmp/cluster_share"

  8. typedef struct{
  9. char name[4];
  10. int age;
  11. }people;

  12. struct stu {

  13. sem_t mutex;
  14. people s[10];
  15. };

  16. struct stu t;

  17. main(int argc, char** argv) // map a normal file as shared mem:
  18. {
  19. int fd,i;
  20. struct stu *p_map;
  21. char temp;

  22. fd=open(CLUSTER_SHARED_FILE,O_CREAT|O_RDWR,00777);
  23. // lseek(fd,sizeof(people)*5-1,SEEK_SET);
  24. // write(fd,"",1);

  25. p_map = (struct stu *) mmap( NULL,sizeof(t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 );
  26. close( fd );

  27. while(1)
  28. {
  29. sleep(1);
  30. printf("2.....s\n");
  31. sem_wait(&p_map->mutex);
  32. printf("2.....\n");
  33. for(i=0; i<10; i++)
  34. {
  35. printf("name:%s,age:%d\n",p_map->s[i].name,p_map->s[i].age);

  36. }
  37. printf("2.....0\n");
  38. sem_post(&p_map->mutex);
  39. printf("2.......1");
  40. }
  41. munmap( p_map, sizeof(t));
  42. printf( "umap ok \n" );
  43. }
至于并非的写操作,程序稍微修改一下就可以测试. 多并发没有问题.
system V的方式,虽然接口不太一样,但是也很类似。
1. 初始化
  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include

  7. //#include "shmdata.h"




  8. #define TEXT_SZ 2048

  9. struct shared_use_st
  10. {
  11. sem_t mutex;
  12. int written;//作为一个标志,非0:表示可读,0表示可写
  13. char text[TEXT_SZ];//记录写入和读取的文本
  14. int cnt;
  15. };


  16. int main()
  17. {
  18. int running = 1;
  19. void *shm = NULL;
  20. struct shared_use_st *shared = NULL;
  21. char buffer[4096]="hello world";
  22. int shmid;
  23. int i=0;
  24. //创建共享内存
  25. #if 0
  26. //删除共享内存
  27. if(shmctl(shmid, IPC_RMID, 0) == -1)
  28. {
  29. fprintf(stderr, "shmctl(IPC_RMID) failed\n");
  30. exit(EXIT_FAILURE);
  31. }
  32. #endif
  33. shmid = shmget((key_t)12345, sizeof(struct shared_use_st), 0666|IPC_CREAT);
  34. if(shmid == -1)
  35. {
  36. fprintf(stderr, "shmget failed\n");
  37. exit(EXIT_FAILURE);
  38. }
  39. //将共享内存连接到当前进程的地址空间
  40. shm = shmat(shmid, (void*)0, 0);
  41. if(shm == (void*)-1)
  42. {
  43. fprintf(stderr, "shmat failed\n");
  44. exit(EXIT_FAILURE);
  45. }
  46. printf("Memory attached at %X\n", (int)shm);
  47. //设置共享内存
  48. shared = (struct shared_use_st*)shm;
  49. sem_init(&shared->mutex,1,1);

  50. while(running)//向共享内存中写数据
  51. {
  52. strncpy(shared->text, buffer, TEXT_SZ);

  53. sem_wait(&shared->mutex);
  54. //shared->cnt = 0;
  55. shared->cnt = shared->cnt +i;
  56. sem_post(&shared->mutex);
  57. i++;
  58. shared->written = 1;

  59. sleep(1);
  60. }
  61. //把共享内存从当前进程中分离
  62. if(shmdt(shm) == -1)
  63. {
  64. fprintf(stderr, "shmdt failed\n");
  65. exit(EXIT_FAILURE);
  66. }
  67. sleep(2);
  68. exit(EXIT_SUCCESS);
  69. }
2. 读取操作
  1. #include
  2. #include
  3. #include
  4. #include
  5. //#include "shmdata.h"
  6. #include




  7. #define TEXT_SZ 2048

  8. struct shared_use_st
  9. {
  10. sem_t mutex;
  11. int written;//作为一个标志,非0:表示可读,0表示可写
  12. char text[TEXT_SZ];//记录写入和读取的文本
  13. int cnt;
  14. };

  15. int main()
  16. {
  17. int running = 1;//程序是否继续运行的标志
  18. void *shm = NULL;//分配的共享内存的原始首地址
  19. struct shared_use_st *shared;//指向shm
  20. int shmid;//共享内存标识符
  21. //创建共享内存
  22. shmid = shmget((key_t)12345, sizeof(struct shared_use_st), 0666);
  23. if(shmid == -1)
  24. {
  25. fprintf(stderr, "shmget failed\n");
  26. exit(EXIT_FAILURE);
  27. }
  28. //将共享内存连接到当前进程的地址空间
  29. shm = shmat(shmid, 0, 0);
  30. if(shm == (void*)-1)
  31. {
  32. fprintf(stderr, "shmat failed\n");
  33. exit(EXIT_FAILURE);
  34. }
  35. printf("\nMemory attached at %X\n", (int)shm);
  36. //设置共享内存
  37. shared = (struct shared_use_st*)shm;
  38. // shared->written = 0;
  39. while(running)//读取共享内存中的数据
  40. {

  41. sem_wait(&shared->mutex);
  42. printf("text:%s,cnt:%d\n",shared->text,shared->cnt);
  43. sem_post(&shared->mutex);
  44. sleep(1);


  45. }
  46. //把共享内存从当前进程中分离
  47. if(shmdt(shm) == -1)
  48. {
  49. fprintf(stderr, "shmdt failed\n");
  50. exit(EXIT_FAILURE);
  51. }
  52. #if 0
  53. //删除共享内存
  54. if(shmctl(shmid, IPC_RMID, 0) == -1)
  55. {
  56. fprintf(stderr, "shmctl(IPC_RMID) failed\n");
  57. exit(EXIT_FAILURE);
  58. }
  59. #endif
  60. exit(EXIT_SUCCESS);
  61. }

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








猜你会喜欢....

Copyright © 2015 www.wahenzan.com 哇!很赞 版权所有 浙ICP备14030256号-1 Power by DedeCms

浙公网安备 33010602005986号

声明:本站所有文章除标明原创外,均来自网络转载,版权归原作者所有,如果有侵犯到您的权益,请联系本站删除 网站管理员:758763728

360网站安全检测平台