linux进程间通信之管道（无名管道pipe）实现全双工双向通信

梦里梦外; 2021-12-20 15:05 1115阅读 1赞

管道是什么：  
1. 管道只能用于具有亲缘关系的进程之间通信。  
2.管道是一种单工或者说半双工的通信方式，传递信息的方向是固定的，只能由一端传递到另一端。  
  
头文件及函数原型:  
\#include <unistd.h>  
int pipe(int fd\[2\]);  
  
当用pipe 创建管道后，两个文件描述符fd\[0\],fd\[1\]就可以使用了，其中fd\[0\]用于读取，fd\[1\]用于写入。调用管道pipe返回值0表示成功，返回值-1表示失败。  
  
  
pipe函数创建管道后，接着fork出子进程，子进程继承父进程管道。  
  
代码举例来看：

复制代码

运行输出：  
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>
6.  
7.  \#define MAX\_DATA\_LEN 256
8.  \#define DELAY\_TIME 1
9.  
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\];
16. 
17.     memset((void\*)buf,0,sizeof(buf));
18. 
19.     if(pipe(pipe\_fd)<0)\{
20.         perror("Pipe create error!\\n");
21.         exit(1);
22.     \}
23.         
24. 
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);
31. 
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.         \}
39. 
40.         close(pipe\_fd\[0\]);
41.         exit(0);
42.     \} else \{
43.         //close(pipe\_fd\[0\]);
44.         sleep(DELAY\_TIME);
45. 
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.         \}
53. 
54.         close(pipe\_fd\[1\]);
55.         waitpid(pid,NULL,0);
56.         exit(0);
57.     \}
58. 
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>
6.  
7.  \#define MAX\_DATA\_LEN 256
8.  \#define DELAY\_TIME 1
9.  
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\];
16. 
17.     memset((void\*)buf,0,sizeof(buf));
18. 
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.     \}
28. 
29. 
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);
37. 
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.         \}
41. 
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.         \}
45. 
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);
53. 
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.         \}
57. 
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.         \}
61. 
62.         close(pipe\_fd\[1\]);
63.                 close(pipe\_fd2\[0\]);
64.         waitpid(pid,NULL,0);
65.         exit(0);
66.     \}
67. 
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是子写父读，通过两个管道，实现了进程的全双工互相通信。

转载于:https://www.cnblogs.com/wudymand/p/9226417.html