linux進程間通信-共享內存，linux進程通信共享

linux進程間通信-共享內存，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. }

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. }

linux系統的進程間通信有哪幾種方式

# 管道( pipe )：管道是一種半雙工的通信方式，數據只能單向流動，而且只能在具有親緣關系的進程間使用。進程的親緣關系通常是指父子進程關系。
# 有名管道 (named pipe) ： 有名管道也是半雙工的通信方式，但是它允許無親緣關系進程間的通信。
# 信號量( semophore ) ： 信號量是一個計數器，可以用來控制多個進程對共享資源的訪問。它常作為一種鎖機制，防止某進程正在訪問共享資源時，其他進程也訪問該資源。因此，主要作為進程間以及同一進程內不同線程之間的同步手段。
# 消息隊列( message queue ) ： 消息隊列是由消息的鏈表，存放在內核中並由消息隊列標識符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式字節流以及緩沖區大小受限等缺點。
# 信號 ( sinal ) ： 信號是一種比較復雜的通信方式，用於通知接收進程某個事件已經發生。
# 共享內存( shared memory ) ：共享內存就是映射一段能被其他進程所訪問的內存，這段共享內存由一個進程創建，但多個進程都可以訪問。共享內存是最快的 IPC 方式，它是針對其他進程間通信方式運行效率低而專門設計的。它往往與其他通信機制，如信號兩，配合使用，來實現進程間的同步和通信。
# 套接字( socket ) ： 套解口也是一種進程間通信機制，與其他通信機制不同的是，它可用於不同及其間的進程通信。
 

Linux的幾種進程間通信方法簡介

管道（pipe） 管道是Linux支持的最初IPC方式，管道可分為無名管道，有名管道等。 （一）無名管道，它具有幾個特點： 1） 管道是半雙工的，只能支持數據的單向流動；兩進程間需要通信時需要建立起兩個管道； 2） 無名管道使用pipe（）函數創建，只能用於父子進程或者兄弟進程之間； 3） 管道對於通信的兩端進程而言，實質上是一種獨立的文件，只存在於內存中； 4） 數據的讀寫操作：一個進程向管道中寫數據，所寫的數據添加在管道緩沖區的尾部；另一個進程在管道中緩沖區的頭部讀數據。 （二）有名管道 有名管道也是半雙工的，不過它允許沒有親緣關系的進程間進行通信。具體點說就是，有名管道提供了一個路徑名與之進行關聯，以FIFO（先進先出）的形式存在於文件系統中。這樣即使是不相干的進程也可以通過FIFO相互通信，只要他們能訪問已經提供的路徑。 值得注意的是，只有在管道有讀端時，往管道中寫數據才有意義。否則，向管道寫數據的進程會接收到內核發出來的SIGPIPE信號；應用程序可以自定義該信號處理函數，或者直接忽略該信號。 二。信號量（semophore） 信號量是一種計數器，可以控制進程間多個線程或者多個進程對資源的同步訪問，它常實現為一種鎖機制。實質上，信號量是一個被保護的變量，並且只能通過初始化和兩個標准的原子操作（P/V）來訪問。（P,V操作也常稱為wait（s），signal（s）） 三。信號（Signal） 信號是Unix系統中使用的最古老的進程間通信的方法之一。操作系統通過信號來通知某一進程發生了某一種預定好的事件；接收到信號的進程可以選擇不同的方式處理該信號，一是可以采用默認處理機制-進程中斷或退出，一是忽略該信號，還有就是自定義該信號的處理函數，執行相應的動作。 內核為進程生產信號，來響應不同的事件，這些事件就是信號源。信號源可以是：異常，其他進程，終端的中斷（Ctrl-C,Ctrl+\等），作業的控制（前台，後台進程的管理等），分配額問題（cpu超時或文件過大等），內核通知（例如I/O就緒等），報警（計時器）。 四。消息隊列（Message Queue） 消息隊列就是消息的一個鏈表，它允許一個或者多個進程向它寫消息，一個或多個進程向它讀消息。Linux維護了一個消息隊列向量表：msgque,來表示系統中所有的消息隊列。 消息隊列克服了信號傳遞信息少，管道只能支持無格式字節流和緩沖區受限的缺點。 五。共享內存（shared memory） 共享內存映射為一段可以被其他進程訪問的內存。該共享內存由一個進程所創建，然後其他進程可以掛載到該共享內存中。共享內存是最快的IPC機制，但由於linux本身不能實現對其同步控制，需要用戶程序進行並發訪問控制，因此它一般結合了其他通信機制實現了進程間的通信，例如信號量。 五。套接字（socket） socket也是一種進程間的通信機制，不過它與其他通信方式主要的區別是：它可以實現不同主機間的進程通信。