linux進程間通信-共享內存

一 共享內存介紹

     共享內存可以從字面上去理解，就把一片邏輯內存共享出來，讓不同的進程去訪問它，修改它。共享內存是在兩個正在運行的進程之間共享和傳遞數據的一種非常有效的方式。不同進程之間共享的內存通常安排為同一段物理內存。進程可以將同一段共享內存連接到它們自己的地址空間中，所有進程都可以訪問共享內存中的地址，就好像它們是由用C語言函數malloc分配的內存一樣。而如果某個進程向共享內存寫入數據，所做的改動將立即影響到可以訪問同一段共享內存的任何其他進程。

但有一點特別要注意：共享內存並未提供同步機制。也就是說，在第一個進程結束對共享內存的寫操作之前，並無自動機制可以阻止第二個進程開始對它進行讀取。所以我們通常需要用其他的機制來同步對共享內存的訪問，例如信號量。

二 共享內存的使用

 ◆創建共享內存

 int shmget(key_t key, size_t size, int shmflg);

◇第一個參數，共享內存段的命名，shmget函數成功時返回一個與key相關的共享內存標識符（非負整數），用於后續的共享內存函數。調用失敗返回-1.

    ☆其它的進程可以通過該函數的返回值訪問同一共享內存，它代表進程可能要使用的某個資源，程序對所有共享內存的訪問都是間接的，程序先通過調用shmget函數並提供一個鍵，再由系統生成一個相應的共享內存標識符（shmget函數的返回值），只有shmget函數才直接使用信號量鍵，所有其他的信號量函數使用由semget函數返回的信號量標識符。

◇第二個參數，size以字節為單位指定需要共享的內存容量。

◇第三個參數，shmflg是權限標志，它的作用與open函數的mode參數一樣，如果要想在key標識的共享內存不存在時，創建它的話，可以與IPC_CREAT做或操作。共享內存的權限標志與文件的讀寫權限一樣，舉例來說，0644,它表示允許一個進程創建的共享內存被內存創建者所擁有的進程向共享內存讀取和寫入數據，同時其他用戶創建的進程只能讀取共享內存。

 ◆啟動對該共享內存的訪問

void *shmat(int shm_id, const void *shm_addr, int shmflg);

◇第一次創建完共享內存時，它還不能被任何進程訪問，shmat函數的作用就是用來啟動對該共享內存的訪問，並把共享內存連接到當前進程的地址空間。

◇第一個參數，shm_id是由shmget函數返回的共享內存標識。

◇第二個參數，shm_addr指定共享內存連接到當前進程中的地址位置，通常為空，表示讓系統來選擇共享內存的地址。

◇第三個參數，shm_flg是一組標志位，通常為0。

◇調用成功時返回一個指向共享內存第一個字節的指針，如果調用失敗返回-1.

 ◆將共享內存從當前進程中分離

int shmdt(const void *shmaddr);

◇該函數用於將共享內存從當前進程中分離。注意，將共享內存分離並不是刪除它，只是使該共享內存對當前進程不再可用。

◇參數shmaddr是shmat函數返回的地址指針，調用成功時返回0，失敗時返回-1。

 ◆控制共享內存

int shmctl(int shm_id, int command, struct shmid_ds *buf);

◇第一個參數，shm_id是shmget函數返回的共享內存標識符。

◇第二個參數，command是要采取的操作，它可以取下面的三個值 ：

    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"
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。該結構中有個標志written，當共享內存中有其他進程向它寫入數據時，共享內存中的written被設置為0，程序等待。當它不為0時，表示沒有進程對共享內存寫入數據，程序就從共享內存中讀取數據並輸出，然后重置設置共享內存中的written為0，即讓其可被shmwrite進程寫入數據。

◇程序shmwrite取得共享內存並連接到自己的地址空間中。檢查共享內存中的written，是否為0，若不是，表示共享內存中的數據還沒有被完，則等待其他進程讀取完成，並提示用戶等待。若共享內存的written為0，表示沒有其他進程對共享內存進行讀取，則提示用戶輸入文本，並再次設置共享內存中的written為1，表示寫完成，其他進程可對共享內存進行讀操作。

◆ 關於前面的例子的安全性討論

這個程序是不安全的，當有多個程序同時向共享內存中讀寫數據時，問題就會出現。可能你會認為，可以改變一下written的使用方式，例如，只有當written為0時進程才可以向共享內存寫入數據，而當一個進程只有在written不為0時才能對其進行讀取，同時把written進行加1操作，讀取完后進行減1操作。這就有點像文件鎖中的讀寫鎖的功能。咋看之下，它似乎能行得通。但是這都不是原子操作，所以這種做法是行不能的。試想當written為0時，如果有兩個進程同時訪問共享內存，它們就會發現written為0，於是兩個進程都對其進行寫操作，顯然不行。當written為1時，有兩個進程同時對共享內存進行讀操作時也是如些，當這兩個進程都讀取完是，written就變成了-1.

要想讓程序安全地執行，就要有一種進程同步的進制，保證在進入臨界區的操作是原子操作。例如，可以使用前面所講的信號量來進行進程的同步。因為信號量的操作都是原子性的。

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>
8. #include"credis.h"
10. int semid;
11. int shmid;
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. }
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. }
36. int main()
37. {
38. structPeople{
39. char name[10];
40. int age;
41. };
43. key_t semkey;
44. key_t shmkey;
45. semkey=ftok("../test/VenusDB.cbp",0);//用來產生唯一的標志符，便於區分信號量及共享內存
46. shmkey=ftok("../test/main.c",0);
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");
65. /*設置信號量的初始值，就是資源個數*/
66. union semun{
67. int val;
68. struct semid_ds *buf;
69. unsignedshort*array;
70. }sem_u;
72. sem_u.val=1;/*設置變量值*/
73. semctl(semid,0,SETVAL,sem_u);//初始化信號量，設置第0個信號量，p()操作為非阻塞的
75. /*將共享內存映射到當前進程的地址中，之后直接對進程中的地址addr操作就是對共享內存操作*/
77. structPeople*addr;
78. addr=(structPeople*)shmat(shmid,0,0);//將共享內存映射到調用此函數的內存段
79. if(addr==(structPeople*)-1)
80. printf("shm shmat is fail\n");
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();
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>
7. int semid;
8. int shmid;
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. }
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. }
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);
37. structPeople{
38. char name[10];
39. int age;
40. };
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");
50. /*將共享內存映射到當前進程的地址中，之后直接對進程中的地址addr操作就是對共享內存操作*/
51. structPeople*addr;
52. addr=(structPeople*)shmat(shmid,0,0);
53. if(addr==(structPeople*)-1)
54. printf("shm shmat is fail\n");
56. /*從共享內存讀出數據*/
57. p();
58. printf("name:%s\n",addr->name);
59. printf("age:%d\n",addr->age);
60. v();
62. /*將共享內存與當前進程斷開*/
63. if(shmdt(addr)==-1)
64. printf("shmdt is fail\n");
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>
6. #define SHM_KEY 0x33
7. #define SEM_KEY 0x44
9. union semun {
10. int val;
11. struct semid_ds *buf;
12. unsignedshort*array;
13. };
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;
22. if(semop(semid,&sb,1)==-1){
23. perror("semop");
24. return-1;
25. }
26. return0;
27. }
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;
36. if(semop(semid,&sb,1)==-1){
37. perror("semop");
38. return-1;
39. }
40. return0;
41. }
43. int main(int argc,char**argv)
44. {
45. pid_t pid;
46. int i, shmid, semid;
47. int*ptr;
48. union semun semopts;
50. /* 創建一塊共享內存, 存一個int變量 */
51. if((shmid = shmget(SHM_KEY,sizeof(int), IPC_CREAT |0600))==-1){
52. perror("msgget");
53. }
55. /* 將共享內存映射到進程, fork后子進程可以繼承映射 */
56. if((ptr =(int*)shmat(shmid, NULL,0))==(void*)-1){
57. perror("shmat");
58. }
59. *ptr =0;
61. /* 創建一個信號量用來同步共享內存的操作 */
62. if((semid = semget(SEM_KEY,1, IPC_CREAT |0600))==-1){
63. perror("semget");
64. }
66. /* 初始化信號量 */
67. semopts.val =1;
68. if(semctl(semid,0, SETVAL, semopts)<0){
69. perror("semctl");
70. }
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. }
96. return0;
97. }

 

 

 

 

來自為知筆記(Wiz)