linux進程間通信之管道（無名管道pipe）實現全雙工雙向通信

管道是什么：
1. 管道只能用於具有親緣關系的進程之間通信。
2.管道是一種單工或者說半雙工的通信方式，傳遞信息的方向是固定的，只能由一端傳遞到另一端。

頭文件及函數原型:
#include <unistd.h>
int pipe(int fd[2]);

當用pipe 創建管道后，兩個文件描述符fd[0],fd[1]就可以使用了，其中fd[0]用於讀取，fd[1]用於寫入。調用管道pipe返回值0表示成功，返回值-1表示失敗。


pipe函數創建管道后，接着fork出子進程，子進程繼承父進程管道。

代碼舉例來看：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. #define MAX_DATA_LEN 256
8. #define DELAY_TIME 1
10. int main() {
11.     pid_t pid;
12.     char buf[MAX_DATA_LEN];
13.     const char *data="Pipe Test";
14.     int real_read,real_write;
15.     int pipe_fd[2];
17.     memset((void*)buf,0,sizeof(buf));
19.     if(pipe(pipe_fd)<0){
20.         perror("Pipe create error!\n");
21.         exit(1);
22.     }
23.         
25.     if ((pid=fork())<0) {
26.         perror("Fork error!\n");
27.         exit(1);
28.     } else if (pid==0) {
29.         close(pipe_fd[1]);
30.         sleep(DELAY_TIME*3);
32.         if ((real_read=read(pipe_fd[0],buf,MAX_DATA_LEN))>0) {
33.             printf("Child receive %d bytes from pipe: '%s'.\n",real_read,buf);
34.         }
36.         close(pipe_fd[0]);
37.         exit(0);
38.     } else {
39.         close(pipe_fd[0]);
40.         sleep(DELAY_TIME);
42.         if ((real_write=write(pipe_fd[1],data,strlen(data)))>0) {
43.             printf("Parent write %d bytes into pipe: '%s'.\n",real_write,data);
44.         }
46.         close(pipe_fd[1]);
47.         waitpid(pid,NULL,0);
48.         exit(0);
49.     }
51. }

復制代碼

運行輸出：
Parent write 9 bytes into pipe: 'Pipe Test'.
Child receive 9 bytes from pipe: 'Pipe Test'.

 

 

上述代碼只能從父進程向子進程傳遞，如何從子進程向父進程傳遞呢？我們看到父進程關閉了管道讀取端“close(pipe_fd[0]);”，子進程關閉了管道寫入端“close(pipe_fd[1]);”，如果取消關閉這兩個端，是否能夠實現子進程向父進程傳遞呢。
父進程先發送，子進程接收，然后子進程再發送，父進程再接收，實現全雙工互相通信，期望運行結果如下：
Parent write 9 bytes into pipe: 'Pipe Test'.
Child receive 9 bytes from pipe: 'Pipe Test'.
Child write 9 bytes from pipe: 'Pipe Test'.
Parent receive 9 bytes from pipe: 'Pipe Test'.

修改代碼如下：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. #define MAX_DATA_LEN 256
8. #define DELAY_TIME 1
10. int main() {
11.     pid_t pid;
12.     char buf[MAX_DATA_LEN];
13.     const char *data="Pipe Test";
14.     int real_read,real_write;
15.     int pipe_fd[2];
17.     memset((void*)buf,0,sizeof(buf));
19.     if(pipe(pipe_fd)<0){
20.         perror("Pipe create error!\n");
21.         exit(1);
22.     }
23.         
25.     if ((pid=fork())<0) {
26.         perror("Fork error!\n");
27.         exit(1);
28.     } else if (pid==0) {
29.         //close(pipe_fd[1]);
30.         sleep(DELAY_TIME*3);
32.         if ((real_read=read(pipe_fd[0],buf,MAX_DATA_LEN))>0) {
33.             printf("Child receive %d bytes from pipe: '%s'.\n",real_read,buf);
34.         }
35.                 
36.                 if ((real_write=write(pipe_fd[1],data,strlen(data)))>0) {
37.             printf("Child write %d bytes into pipe: '%s'.\n",real_write,data);
38.         }
40.         close(pipe_fd[0]);
41.         exit(0);
42.     } else {
43.         //close(pipe_fd[0]);
44.         sleep(DELAY_TIME);
46.         if ((real_write=write(pipe_fd[1],data,strlen(data)))>0) {
47.             printf("Parent write %d bytes into pipe: '%s'.\n",real_write,data);
48.         }
49.                 
50.         if ((real_read=read(pipe_fd[0],buf,MAX_DATA_LEN))>0) {
51.             printf("Parent receive %d bytes from pipe: '%s'.\n",real_read,buf);
52.         }
54.         close(pipe_fd[1]);
55.         waitpid(pid,NULL,0);
56.         exit(0);
57.     }
59. }

復制代碼

但是實際運行如下：
Parent write 9 bytes into pipe: 'Pipe Test'.
Parent receive 9 bytes from pipe: 'Pipe Test'.


可以看到，父進程發送的數據被父進程自己接收了，子進程讀不到數據被阻塞了。顯然這種方法不行。

 

 

因為管道是單工的，只能固定從一個方向傳遞到另一個方向。
要實現互相通信，一個管道是不行的，可以創建兩個管道，一個管道是父寫子讀，另一個是子寫父讀。
代碼如下：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <sys/types.h>
5. #include <unistd.h>
7. #define MAX_DATA_LEN 256
8. #define DELAY_TIME 1
10. int main() {
11.     pid_t pid;
12.     char buf[MAX_DATA_LEN];
13.     const char *data="Pipe Test";
14.     int real_read,real_write;
15.     int pipe_fd[2],pipe_fd2[2];
17.     memset((void*)buf,0,sizeof(buf));
19.     if(pipe(pipe_fd)<0){
20.         perror("Pipe create error!\n");
21.         exit(1);
22.     }
23.         
24.         if(pipe(pipe_fd2)<0){
25.         perror("Pipe create error!\n");
26.         exit(1);
27.     }
30.     if ((pid=fork())<0) {
31.         perror("Fork error!\n");
32.         exit(1);
33.     } else if (pid==0) {
34.         close(pipe_fd[1]);
35.                 close(pipe_fd2[0]);
36.         sleep(DELAY_TIME*3);
38.         if ((real_read=read(pipe_fd[0],buf,MAX_DATA_LEN))>0) {
39.             printf("Child receive %d bytes from pipe: '%s'.\n",real_read,buf);
40.         }
42.                 if ((real_write=write(pipe_fd2[1],data,strlen(data)))>0) {
43.             printf("Child write %d bytes into pipe: '%s'.\n",real_write,data);
44.         }
46.         close(pipe_fd[0]);
47.                 close(pipe_fd2[1]);
48.         exit(0);
49.     } else {
50.         close(pipe_fd[0]);
51.                 close(pipe_fd2[1]);
52.         sleep(DELAY_TIME);
54.         if ((real_write=write(pipe_fd[1],data,strlen(data)))>0) {
55.             printf("Parent write %d bytes into pipe: '%s'.\n",real_write,data);
56.         }
58.                 if ((real_read=read(pipe_fd2[0],buf,MAX_DATA_LEN))>0) {
59.             printf("Parent  receive %d bytes from pipe: '%s'.\n",real_read,buf);
60.         }
62.         close(pipe_fd[1]);
63.                 close(pipe_fd2[0]);
64.         waitpid(pid,NULL,0);
65.         exit(0);
66.     }
68. }

復制代碼

運行結果：
Parent write 9 bytes into pipe: 'Pipe Test'.
Child receive 9 bytes from pipe: 'Pipe Test'.
Child write 9 bytes into pipe: 'Pipe Test'.
Parent  receive 9 bytes from pipe: 'Pipe Test'.


可以看到，創建了兩個管道 “int pipe_fd[2],pipe_fd2[2];”,
pipe_fd 是父寫子讀，pipe_fd2是子寫父讀，通過兩個管道，實現了進程的全雙工互相通信。