Linuxのプロセス間通信 - 共有メモリ

Linuxのプロセス間通信 - 共有メモリ

共有メモリの紹介

     共有メモリアクセスに異なるプロセスが、それは、それを修正するようにすることを、論理共有メモリを出して、文字通りに理解することができます。メモリを共有するための2つのプロセス間で共有され、渡されたデータを実行している非常に効率的な方法です。メモリの異なるプロセス間で共有通常、物理メモリの同じ期間に予定されています。プロセスが自分の共有メモリアドレス空間の同じ期間に接続することができ、それらが同じmalloc関数C言語関数におけるメモリアロケーションであるかのように、すべてのプロセスが、共有メモリアドレスにアクセスすることができます。プロセスは、共有メモリにデータを書き込む場合と、変更が即座に共有メモリの同じ期間にアクセスすることができ、他のプロセスに影響を与えます。

しかし、一つのことは特に注意：共有メモリは、同期メカニズムを提供していません。最初のプロセスの終了は、共有メモリへの書き込みを行う前に、すなわち、第二の方法は、それを読み始めた自動的なメカニズムの防止はありません。多くの場合、セマフォなど、共有メモリへのアクセスを同期するために他のメカニズムを使用する必要があり、我々はそう。

2回の共有メモリ使用量

 ◆共有メモリを作成します

 INTたshmget（key_tのキー、size_tのサイズ、int型のshmflg）。

◇リターンキーに関連付けられた最初のパラメータは、メモリ識別子（非負の整数）という名前の共有メモリ・セグメントたshmget関数が成功し、その後の機能のために共有メモリを共有しました。呼び出しが戻るために失敗した-1。

    ☆同じ共有メモリリソースにアクセスするための関数の値を返すことができ、プロセスを表すプログラムがアクセスすべての共用メモリに使用することができる他のプロセスは、間接的であり、最初のプログラムたshmget関数を呼び出すと、キーを提供することにより、次いで、対応する共有メモリ識別子（たshmget関数の戻り値）、直接使用のみたshmgetセマフォ機能キー、関数semgetからシステムによって返されたセマフォ識別子で使用されるすべての他の信号の量の関数を生成します。

◇バイトの2番目のパラメータ、サイズが必要な共有メモリ容量を指定しました。

それは共有メモリにキーを特定することである場合◇三番目のパラメータ、shmflg権限記号、同じモードパラメータが開いにおけるその役割と機能は、あなたがIPC_CREATを行うか、操作することができ、それを作成し、存在しません。ファイル許可フラグにメモリの読み取りおよび書き込み権限を共有、他の人が作成している間のような、例えば、プロセスを表し0644は、共有メモリの読み取りと書き込みのデータへのプロセスメモリの作成者が所有する共有メモリを作成することができますプロセスは、共有メモリを読み取ることができます。

 ◆共有メモリアクセスを開始

void *型にshmat（int型shm_id、CONST void *型shm_addr、INT shmflg）。

完了したら、最初の共有メモリを作成し、それが任意のプロセスによってアクセスすることができない◇、にshmat関数の役割は、現在のプロセスのアドレス空間に接続された共有メモリと共有メモリへのアクセスを開始するために使用されます。

◇最初のパラメータは、shm_idたshmgetは共有メモリを特定の関数によって返されます。

◇第2のパラメータは、共有メモリアドレスを選択するようにシステムに伝えるために、空通常、現在のプロセスのアドレス位置に接続された共有メモリを指定shm_addr。

◇3番目のパラメータは、shm_flgは、典型的には0、ビットのグループです。

戻り値共有メモリポインタの最初のバイトへのポインタを◇呼び出しが成功し、-1を返し呼び出しが失敗した場合。

 ◆共有メモリは、現在のプロセスとは別に

int型にshmdt（のconst void *型は、shmaddr）。

◇この関数は、現在のプロセスから別の共有メモリを用いています。共有メモリは共有メモリの現在のプロセスが使用できなくなっただけのこと、それを削除しないように隔離されていないことに注意してください。

◇パラメータは関数によって返さは、shmaddrにshmatアドレスポインタで、0を返します呼び出しが成功した場合、失敗した場合は-1。

 ◆共有メモリ制御

int型shmctl（int型shm_id、int型のコマンド、構造体するshmid_ds * BUF）。

◇最初のパラメータ、shm_idたshmget関数は、共有メモリ識別子を返します。

◇第二のパラメータ、コマンド動作が取られるべきである、それは次の3つの値をとることができます。

    IPC_STATは：関連する共有メモリの現在値と、共有メモリの現在の設定値に関連付けられたデータ構造をするshmid_dsすなわちするshmid_dsカバレッジ値。

    IPC_SET：プロセスは、現在の値が値構造特定するshmid_dsに設定されているに関連付けられている共有メモリを置くのに十分な権限を持っている場合

    IPC_RMID：共有メモリセグメントを削除します。

◇第三のパラメータは、buf構造体は、共有メモリ・アクセス・パターンおよび構造へのポインタです。

 

1. struct shmid_ds
2. {
3. uid_t shm_perm.uid;
4. uid_t shm_perm.gid;
5. mode_t shm_perm.mode;
6. }

 

三つの例

shmdata.hソース：

 

1. #ifndef _SHMDATA_H_HEADER
2. #define _SHMDATA_H_HEADER
3. #define TEXT_SZ 2048
4. struct shared_use_st
5. {
6. int written;/* 作为一个标志，非0：表示可读，0表示可写 */
7. char text[TEXT_SZ];/* 记录写入和读取的文本 */
8. };
9. #endif

 

shmread.cソース

 

1. #include<unistd.h>
2. #include<stdlib.h>
3. #include<stdio.h>
4. #include<sys/shm.h>
5. #include"shmdata.h"

1.  
2. #define MEM_KEY（1234）
3.  
4. int main()
5. {
6. int running =1; //程序是否继续运行的标志
7. void*shm = NULL; //分配的共享内存的原始首地址
8. struct shared_use_st *shared;//指向shm
9. int shmid; //共享内存标识符
10. //创建共享内存
11.  
12. shmid = shmget((key_t)MEM_KEY,sizeof(struct shared_use_st),0666|IPC_CREAT);
13. if(shmid ==-1)
14. {
15. fprintf(stderr,"shmget failed\n");
16. exit(EXIT_FAILURE);
17. }
18. //将共享内存连接到当前进程的地址空间
19. shm = shmat(shmid,0,0);
20. if(shm ==(void*)-1)
21. {
22. fprintf(stderr,"shmat failed\n");
23. exit(EXIT_FAILURE);
24. }
25. printf("\nMemory attached at %X\n",(int)shm);
26. //设置共享内存
27. shared =(struct shared_use_st*)shm;
28. shared->written =0;
29. while(running)//读取共享内存中的数据
30. {
31. //没有进程向共享内存定数据有数据可读取
32. if(shared->written !=0)
33. {
34. printf("You wrote: %s", shared->text);
35. sleep(rand()%3);
36. //读取完数据，设置written使共享内存段可写
37. shared->written =0;
38. //输入了end，退出循环（程序）
39. if(strncmp(shared->text,"end",3)==0)
40. running =0;
41. }
42. else//有其他进程在写数据，不能读取数据
43. sleep(1);
44. }
45. //把共享内存从当前进程中分离
46. if(shmdt(shm)==-1)
47. {
48. fprintf(stderr,"shmdt failed\n");
49. exit(EXIT_FAILURE);
50. }
51. //删除共享内存
52. if(shmctl(shmid, IPC_RMID,0)==-1)
53. {
54. fprintf(stderr,"shmctl(IPC_RMID) failed\n");
55. exit(EXIT_FAILURE);
56. }
57. exit(EXIT_SUCCESS);
58. }

 

shmwrite.cソース

 

1. #include<unistd.h>
2. #include<stdlib.h>
3. #include<stdio.h>
4. #include<string.h>
5. #include<sys/shm.h>
6. #include"shmdata.h"
7.  
8. #define MEM_KEY (1234)
9.  
10. int main()
11. {
12. int running =1;
13. void*shm = NULL;
14. struct shared_use_st *shared = NULL;
15. char buffer[BUFSIZ +1];//用于保存输入的文本
16. int shmid;
17. //创建共享内存
18. shmid = shmget((key_t)MEM_KEY,sizeof(struct shared_use_st),0666|IPC_CREAT);
19. if(shmid ==-1)
20. {
21. fprintf(stderr,"shmget failed\n");
22. exit(EXIT_FAILURE);
23. }
24. //将共享内存连接到当前进程的地址空间
25. shm = shmat(shmid,(void*)0,0);
26. if(shm ==(void*)-1)
27. {
28. fprintf(stderr,"shmat failed\n");
29. exit(EXIT_FAILURE);
30. }
31. printf("Memory attached at %X\n",(int)shm);
32. //设置共享内存
33. shared =(struct shared_use_st*)shm;
34. while(running)//向共享内存中写数据
35. {
36. //数据还没有被读取，则等待数据被读取,不能向共享内存中写入文本
37. while(shared->written ==1)
38. {
39. sleep(1);
40. printf("Waiting...\n");
41. }
42. //向共享内存中写入数据
43. printf("Enter some text: ");
44. fgets(buffer, BUFSIZ, stdin);
45. strncpy(shared->text, buffer, TEXT_SZ);
46. //写完数据，设置written使共享内存段可读
47. shared->written =1;
48. //输入了end，退出循环（程序）
49. if(strncmp(buffer,"end",3)==0)
50. running =0;
51. }
52. //把共享内存从当前进程中分离
53. if(shmdt(shm)==-1)
54. {
55. fprintf(stderr,"shmdt failed\n");
56. exit(EXIT_FAILURE);
57. }
58. sleep(2);
59. exit(EXIT_SUCCESS);
60. }

 

◆コード解析：

◇プログラムは、共有メモリを作成し、自分のアドレス空間に接続しshmread。共有メモリの先頭に構造struct_use_stを使用してください。構造が0、プログラム待機に設定されている共有メモリに書き込まれ、それへの書き込みデータ、共有メモリ内の他のプロセスがある場合、書き込まれたフラグを有しています。それが0でない場合、プロセスは、書き込みデータへの共有メモリがないことを示し、プログラムが共有メモリと出力からデータを読み取り、次いで0に共有メモリに書き込まれた設定をリセット、即ちプロセスshmwriteに書き込むことを許可データ。

◇プログラムは、共有メモリを取得し、独自のアドレス空間に接続しshmwrite。書かれた共有メモリをチェックし、それがない場合は、共有メモリ内のデータが終了していない表し、他方が待機するようユーザーを読み、プロンプトのプロセスを完了するのを待ち、0です。共有メモリは、共有メモリへの他のプロセスが読み取らないことを示し、ゼロに書き込まれている場合、ユーザーがテキストを入力するように要求し、再度共有メモリは、書き込みが完了したことを示す、1に書き込ま設定され、他のプロセスは、共有メモリ上に読み込むことができます。

前の例について◆セキュリティディスカッション

このプログラムは安全ではない、複数のプログラムが同時に共有メモリへの読み込みと書き込みデータがある場合、問題が発生します。あなたは、同時に、例えば、0のプロセスに書き込まれた場合にのみ、プロセスは唯一の0:00読み取ることが書かれていない場合、共有メモリにデータを書き込むことができ、使用を変更するために書かれたことができると思うかもしれません書かれた、インクリメント読み出し動作の後にデクリメントされます。これは、ビット読み書きロックファイルロック機能のようなものです。一見は、動作しているようです。しかし、これはアトミック操作ではありませんので、この練習はラインではありません。書かれた時に想像して2つのプロセスが同時に存在する場合、0である共有メモリにアクセスし、それらを0として書き込まれ、そう書かれている両方のプロセス、明らかではないでしょう。1が書き込まれたときに2つのプロセスが完了すると、このような読み出し動作と2つのプロセスがあり、同時に、共有メモリは、複数ある読み取られ、書き込ま-1となります。

プログラムが安全に行わ取得するために、重要な領域は、アトミック操作であることを保証するために操作に、それにより2進データ同期プロセスが存在すべきです。例えば、信号の量は、以前の同期処理に話さ。すべてのアトミックセマフォ操作以来。

共有メモリを使用しての3つの長所と短所

◇利点：我々は共有メモリ通信の使用を見ることができ、本当にプロセスの間に非常に便利ですが、また、インタフェース機能、データ共有もプロセス間のデータ転送ませんが、メモリへの直接アクセス、また加速プログラムを、単純なことができます効率。また、匿名パイプライン処理の通信は、いくつかの父と息子の関係を持って要求されていません。

◇短所：共有メモリは、他の手段によって、多くの場合、プロセス間の同期作業に、プロセス間通信用の共有メモリの使用で私たちを行い同期化するためにメカニズムを、提供されていません。

四の、より良い例

1、server.c

 

1. /*server.c:向共享内存中写入People*/
2. #include<stdio.h>
3. #include<sys/types.h>
4. #include<sys/ipc.h>
5. #include<sys/sem.h>
6. #include<string.h>
7.  
8. #include"credis.h"
9.  
10. int semid;
11. int shmid;
12.  
13. /*信号量的P操作*/
14. void p()
15. {
16. struct sembuf sem_p;
17. sem_p.sem_num=0;/*设置哪个信号量*/
18. sem_p.sem_op=-1;/*定义操作*/
19. if(semop(semid,&sem_p,1)==-1)
20. printf("p operation is fail\n");
21. /*semop函数自动执行信号量集合上的操作数组。
22. 　　 int semop(int semid, struct sembuf semoparray[], size_t nops);
23. 　　 semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。*/
24. }
25.  
26. /*信号量的V操作*/
27. void v()
28. {
29. struct sembuf sem_v;
30. sem_v.sem_num=0;
31. sem_v.sem_op=1;
32. if(semop(semid,&sem_v,1)==-1)
33. printf("v operation is fail\n");
34. }
35.  
36. int main()
37. {
38. structPeople{
39. char name[10];
40. int age;
41. };
42.  
43. key_t semkey;
44. key_t shmkey;
45. semkey=ftok("../test/VenusDB.cbp",0);//用来产生唯一的标志符，便于区分信号量及共享内存
46. shmkey=ftok("../test/main.c",0);
47.  
48. /*创建信号量的XSI IPC*/
49. semid=semget(semkey,1,0666|IPC_CREAT);//参数nsems,此时为中间值1，指定信号灯集包含信号灯的数目
50. //0666|IPC_CREAT用来表示对信号灯的读写权限
51. /*
52. 从左向右:
53. 第一位:0表示这是一个8进制数
54. 第二位:当前用户的经权限:6=110(二进制),每一位分别对就 可读,可写,可执行,6说明当前用户可读可写不可执行
55. 第三位:group组用户,6的意义同上
56. 第四位:其它用户,每一位的意义同上,0表示不可读不可写也不可执行
57. */
58. if(semid==-1)
59. printf("creat sem is fail\n");
60. //创建共享内存
61. shmid=shmget(shmkey,1024,0666|IPC_CREAT);//对共享内存
62. if(shmid==-1)
63. printf("creat shm is fail\n");
64.  
65. /*设置信号量的初始值，就是资源个数*/
66. union semun{
67. int val;
68. struct semid_ds *buf;
69. unsignedshort*array;
70. }sem_u;
71.  
72. sem_u.val=1;/*设置变量值*/
73. semctl(semid,0,SETVAL,sem_u);//初始化信号量，设置第0个信号量，p()操作为非阻塞的
74.  
75. /*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
76.  
77. structPeople*addr;
78. addr=(structPeople*)shmat(shmid,0,0);//将共享内存映射到调用此函数的内存段
79. if(addr==(structPeople*)-1)
80. printf("shm shmat is fail\n");
81.  
82. /*向共享内存写入数据*/
83. p();
84. strcpy((*addr).name,"xiaoming");
85. /*注意：①此处只能给指针指向的地址直接赋值，不能在定义一个 struct People people_1;addr=&people_1;因为addr在addr=(struct People*)shmat(shmid,0,0);时,已经由系统自动分配了一个地址，这个地址与共享内存相关联，所以不能改变这个指针的指向，否则他将不指向共享内存，无法完成通信了。
86. 注意：②给字符数组赋值的方法。刚才太虎了。。*/
87. (*addr).age=10;
88. v();
89.  
90. /*将共享内存与当前进程断开*/
91. if(shmdt(addr)==-1)
92. printf("shmdt is fail\n");
93. }

2、clinet.c

1. /*client.c:从共享内存中读出People*/
2. #include<stdio.h>
3. #include<sys/types.h>
4. #include<sys/ipc.h>
5. #include<sys/sem.h>
6.  
7. int semid;
8. int shmid;
9.  
10. /*信号量的P操作*/
11. void p()
12. {
13. struct sembuf sem_p;
14. sem_p.sem_num=0;
15. sem_p.sem_op=-1;
16. if(semop(semid,&sem_p,1)==-1)
17. printf("p operation is fail\n");
18. }
19.  
20. /*信号量的V操作*/
21. void v()
22. {
23. struct sembuf sem_v;
24. sem_v.sem_num=0;
25. sem_v.sem_op=1;
26. if(semop(semid,&sem_v,1)==-1)
27. printf("v operation is fail\n");
28. }
29.  
30. int main()
31. {
32. key_t semkey;
33. key_t shmkey;
34. semkey=ftok("../test/client/VenusDB.cbp",0);
35. shmkey=ftok("../test/client/main.c",0);
36.  
37. structPeople{
38. char name[10];
39. int age;
40. };
41.  
42. /*读取共享内存和信号量的IPC*/
43. semid=semget(semkey,0,0666);
44. if(semid==-1)
45. printf("creat sem is fail\n");
46. shmid=shmget(shmkey,0,0666);
47. if(shmid==-1)
48. printf("creat shm is fail\n");
49.  
50. /*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
51. structPeople*addr;
52. addr=(structPeople*)shmat(shmid,0,0);
53. if(addr==(structPeople*)-1)
54. printf("shm shmat is fail\n");
55.  
56. /*从共享内存读出数据*/
57. p();
58. printf("name:%s\n",addr->name);
59. printf("age:%d\n",addr->age);
60. v();
61.  
62. /*将共享内存与当前进程断开*/
63. if(shmdt(addr)==-1)
64. printf("shmdt is fail\n");
65.  
66. /*IPC必须显示删除。否则会一直留存在系统中*/
67. if(semctl(semid,0,IPC_RMID,0)==-1)
68. printf("semctl delete error\n");
69. if(shmctl(shmid,IPC_RMID,NULL)==-1)
70. printf("shmctl delete error\n");
71. }

ファイブ父と息子は、メモリサブプロセスを共有しました

1. #include<stdio.h>
2. #include<sys/types.h>
3. #include<sys/ipc.h>
4. #include<sys/sem.h>
5.  
6. #define SHM_KEY 0x33
7. #define SEM_KEY 0x44
8.  
9. union semun {
10. int val;
11. struct semid_ds *buf;
12. unsignedshort*array;
13. };
14.  
15. int P(int semid)
16. {
17. struct sembuf sb;
18. sb.sem_num =0;
19. sb.sem_op =-1;
20. sb.sem_flg = SEM_UNDO;
21.  
22. if(semop(semid,&sb,1)==-1){
23. perror("semop");
24. return-1;
25. }
26. return0;
27. }
28.  
29. int V(int semid)
30. {
31. struct sembuf sb;
32. sb.sem_num =0;
33. sb.sem_op =1;
34. sb.sem_flg = SEM_UNDO;
35.  
36. if(semop(semid,&sb,1)==-1){
37. perror("semop");
38. return-1;
39. }
40. return0;
41. }
42.  
43. int main(int argc,char**argv)
44. {
45. pid_t pid;
46. int i, shmid, semid;
47. int*ptr;
48. union semun semopts;
49.  
50. /* 创建一块共享内存, 存一个int变量 */
51. if((shmid = shmget(SHM_KEY,sizeof(int), IPC_CREAT |0600))==-1){
52. perror("msgget");
53. }
54.  
55. /* 将共享内存映射到进程, fork后子进程可以继承映射 */
56. if((ptr =(int*)shmat(shmid, NULL,0))==(void*)-1){
57. perror("shmat");
58. }
59. *ptr =0;
60.  
61. /* 创建一个信号量用来同步共享内存的操作 */
62. if((semid = semget(SEM_KEY,1, IPC_CREAT |0600))==-1){
63. perror("semget");
64. }
65.  
66. /* 初始化信号量 */
67. semopts.val =1;
68. if(semctl(semid,0, SETVAL, semopts)<0){
69. perror("semctl");
70. }
71.  
72. if((pid = fork())<0){
73. perror("fork");
74. }elseif(pid ==0){/* Child */
75. /* 子进程对共享内存加1 */
76. for(i =0; i <100; i++){
77. P(semid);
78. (*ptr)++;
79. V(semid);
80. printf("child: %d\n",*ptr);
81. }
82. }else{/* Parent */
83. /* 父进程对共享内存减1 */
84. for(i =0; i <100; i++){
85. P(semid);
86. (*ptr)--;
87. V(semid);
88. printf("parent: %d\n",*ptr);
89. }
90. waitpid(pid);
91. sleep(2);
92. /* 如果同步成功, 共享内存的值为0 */
93. printf("finally: %d\n",*ptr);
94. }
95.  
96. return0;
97. }