Linux进程间通信——使用命名管道

迷南。 2022-06-14 08:30 237阅读 0赞

在前一篇文章——  [Linux进程间通信——使用匿名管道][Linux]中，我们看到了如何使用匿名管道来在进程之间传递数据，同时也看到了这个方式的一个缺陷，就是这些进程都由一个共同的祖先进程启动，这给我们在不相关的的进程之间交换数据带来了不方便。这里将会介绍进程的另一种通信方式——命名管道，来解决不相关进程间的通信问题。

一、什么是命名管道

命名管道也被称为FIFO文件，它是一种特殊类型的文件，它在文件系统中以文件名的形式存在，但是它的行为却和之前所讲的没有名字的管道（匿名管道）类似。

由于Linux中所有的事物都可被视为文件，所以对命名管道的使用也就变得与文件操作非常的统一，也使它的使用非常方便，同时我们也可以像平常的文件名一样在命令中使用。

二、创建命名管道

我们可以使用两下函数之一来创建一个命名管道，他们的原型如下：

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include <sys/types.h>
2.  \#include <sys/stat.h>
3.  **int** mkfifo(**const****char** \*filename, mode\_t mode); 
4.  **int** mknod(**const****char** \*filename, mode\_t mode | S\_IFIFO, (dev\_t)0);

这两个函数都能创建一个FIFO文件，注意是创建一个真实存在于文件系统中的文件，filename指定了文件名，而mode则指定了文件的读写权限。

mknod是比较老的函数，而使用mkfifo函数更加简单和规范，所以建议在可能的情况下，尽量使用mkfifo而不是mknod。

三、访问命名管道

1、打开FIFO文件

与打开其他文件一样，FIFO文件也可以使用open调用来打开。注意，mkfifo函数只是创建一个FIFO文件，要使用命名管道还是将其打开。

但是有两点要 注意，1、就是程序不能以O\_RDWR模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程就会读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递。2、就是传递给open调用的是FIFO的路径名，而不是正常的文件。

打开FIFO文件通常有四种方式，

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  open(**const****char** \*path, O\_RDONLY);//1
2.  open(**const****char** \*path, O\_RDONLY | O\_NONBLOCK);//2
3.  open(**const****char** \*path, O\_WRONLY);//3
4.  open(**const****char** \*path, O\_WRONLY | O\_NONBLOCK);//4

在open函数的调用的第二个参数中，你看到一个陌生的选项O\_NONBLOCK，选项O\_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的。

open调用的阻塞是什么一回事呢？很简单，对于以只读方式（O\_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O\_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O\_RDONLY | O\_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

对于以只写方式（O\_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O\_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O\_WRONLY | O\_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

四、使用FIFO实现进程间的通信

说了这么多，下面就用一个例子程序来说明一下，两个进程如何通过FIFO实现通信吧。这里有两个源文件，一个fifowrite.c，它在需要时创建管道，然后向管道写入数据,数据由文件Data.txt提供，大小为10M，内容全是字符‘0’。另一个源文件为fiforead.c，它从FIFO中读取数据，并把读到的数据保存到另一个文件DataFormFIFO.txt中。为了让程序更加简洁，忽略了有些函数调用是否成功的检查。

fifowrite.c的源代码如下：

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include <unistd.h>
2.  \#include <stdlib.h>
3.  \#include <fcntl.h>
4.  \#include <limits.h>
5.  \#include <sys/types.h>
6.  \#include <sys/stat.h>
7.  \#include <stdio.h>
8.  \#include <string.h>
9.  
10. **int** main() 
11. \{ 
12. **const****char** \*fifo\_name = "/tmp/my\_fifo"; 
13. **int** pipe\_fd = -1; 
14. **int** data\_fd = -1; 
15. **int** res = 0; 
16. **const****int** open\_mode = O\_WRONLY; 
17. **int** bytes\_sent = 0; 
18. **char** buffer\[PIPE\_BUF + 1\]; 
19. 
20. **if**(access(fifo\_name, F\_OK) == -1) 
21.  \{ 
22. //管道文件不存在
23. //创建命名管道
24.  res = mkfifo(fifo\_name, 0777); 
25. **if**(res != 0) 
26.  \{ 
27.  fprintf(stderr, "Could not create fifo %s\\n", fifo\_name); 
28.  exit(EXIT\_FAILURE); 
29.  \} 
30.  \} 
31. 
32.  printf("Process %d opening FIFO O\_WRONLY\\n", getpid()); 
33. //以只写阻塞方式打开FIFO文件，以只读方式打开数据文件
34.  pipe\_fd = open(fifo\_name, open\_mode); 
35.  data\_fd = open("Data.txt", O\_RDONLY); 
36.  printf("Process %d result %d\\n", getpid(), pipe\_fd); 
37. 
38. **if**(pipe\_fd != -1) 
39.  \{ 
40. **int** bytes\_read = 0; 
41. //向数据文件读取数据
42.  bytes\_read = read(data\_fd, buffer, PIPE\_BUF); 
43.  buffer\[bytes\_read\] = '\\0'; 
44. **while**(bytes\_read > 0) 
45.  \{ 
46. //向FIFO文件写数据
47.  res = write(pipe\_fd, buffer, bytes\_read); 
48. **if**(res == -1) 
49.  \{ 
50.  fprintf(stderr, "Write error on pipe\\n"); 
51.  exit(EXIT\_FAILURE); 
52.  \} 
53. //累加写的字节数，并继续读取数据
54.  bytes\_sent += res; 
55.  bytes\_read = read(data\_fd, buffer, PIPE\_BUF); 
56.  buffer\[bytes\_read\] = '\\0'; 
57.  \} 
58.  close(pipe\_fd); 
59.  close(data\_fd); 
60.  \} 
61. **else**
62.  exit(EXIT\_FAILURE); 
63. 
64.  printf("Process %d finished\\n", getpid()); 
65.  exit(EXIT\_SUCCESS); 
66. \}

源文件fiforead.c的代码如下：

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include <unistd.h>
2.  \#include <stdlib.h>
3.  \#include <stdio.h>
4.  \#include <fcntl.h>
5.  \#include <sys/types.h>
6.  \#include <sys/stat.h>
7.  \#include <limits.h>
8.  \#include <string.h>
9.  
10. **int** main() 
11. \{ 
12. **const****char** \*fifo\_name = "/tmp/my\_fifo"; 
13. **int** pipe\_fd = -1; 
14. **int** data\_fd = -1; 
15. **int** res = 0; 
16. **int** open\_mode = O\_RDONLY; 
17. **char** buffer\[PIPE\_BUF + 1\]; 
18. **int** bytes\_read = 0; 
19. **int** bytes\_write = 0; 
20. //清空缓冲数组
21.  memset(buffer, '\\0', **sizeof**(buffer)); 
22. 
23.  printf("Process %d opening FIFO O\_RDONLY\\n", getpid()); 
24. //以只读阻塞方式打开管道文件，注意与fifowrite.c文件中的FIFO同名
25.  pipe\_fd = open(fifo\_name, open\_mode); 
26. //以只写方式创建保存数据的文件
27.  data\_fd = open("DataFormFIFO.txt", O\_WRONLY|O\_CREAT, 0644); 
28.  printf("Process %d result %d\\n",getpid(), pipe\_fd); 
29. 
30. **if**(pipe\_fd != -1) 
31.  \{ 
32. **do**
33.  \{ 
34. //读取FIFO中的数据，并把它保存在文件DataFormFIFO.txt文件中
35.  res = read(pipe\_fd, buffer, PIPE\_BUF); 
36.  bytes\_write = write(data\_fd, buffer, res); 
37.  bytes\_read += res; 
38.  \}**while**(res > 0); 
39.  close(pipe\_fd); 
40.  close(data\_fd); 
41.  \} 
42. **else**
43.  exit(EXIT\_FAILURE); 
44. 
45.  printf("Process %d finished, %d bytes read\\n", getpid(), bytes\_read); 
46.  exit(EXIT\_SUCCESS); 
47. \}

运行结果如下：

![SouthEast][]

![Image 1][]

分析：两个程序都使用阻塞模式的FIFO，为了让大家更清楚地看清楚阻塞究竟是怎么一回事，首先我们运行fifowrite.exe，并把它放到后台去运行。这时调用jobs命令，可以看到它确实在后台运行着，过了5秒后，再调用jobs命令，可以看到进程fifowrite.exe还没有结束，它还在继续运行。因为fifowrite.exe进程的open调用是阻塞的，在fiforead.exe还没有运行时，也就没有其他的进程以读方式打开同一个FIFO，所以它就一直在等待，open被阻塞，没有返回。然后，当我们进程fiforead.exe运行时（为了查看性能，在time命令中运行），fifowrite.exe中的open调用返回，进程开始继续工作，然后结束进程。而fiforead.exe的open调用虽然也是阻塞模式，但是fifowrite.exe早已运行，即早有另一个进程以写方式打开同一个FIFO，所以open调用立即返回。

从time中的输出来看，管道的传递效率是非常高的，因为fiforead.exe既要读取数据，还要写数据到文件DataFormFIFO.txt中，10M的数据只用了0.1秒多一点。

此外，如果此时，你在shell中输入如下命令，ls -l /tmp/my\_fifo，可以看到如下结果：

![SouthEast 1][]

![Image 1][]

证明FIFO文件确实是存在于文件系统中的文件，文件属性的第一个字符为‘p'，表示该文件是一个管道。

五、命名管道的安全问题

前面的例子是两个进程之间的通信问题，也就是说，一个进程向FIFO文件写数据，而另一个进程则在FIFO文件中读取数据。试想这样一个问题，只使用一个FIFO文件，如果有多个进程同时向同一个FIFO文件写数据，而只有一个读FIFO进程在同一个FIFO文件中读取数据时，会发生怎么样的情况呢，会发生数据块的相互交错是很正常的？而且个人认为多个不同进程向一个FIFO读进程发送数据是很普通的情况。

为了解决这一问题，就是让写操作的原子化。怎样才能使写操作原子化呢？答案很简单，系统规定：在一个以O\_WRONLY（即阻塞方式）打开的FIFO中， 如果写入的数据长度小于等待PIPE\_BUF，那么或者写入全部字节，或者一个字节都不写入。如果所有的写请求都是发往一个阻塞的FIFO的，并且每个写记请求的数据长度小于等于PIPE\_BUF字节，系统就可以确保数据决不会交错在一起。

六、命名管道与匿名管道的对比

使用匿名管道，则通信的进程之间需要一个父子关系，通信的两个进程一定是由一个共同的祖先进程启动。但是匿名管道没有上面说到的数据交叉的问题。

与使用匿名管道相比，我们可以看到fifowrite.exe和fiforead.exe这两个进程是没有什么必然的联系的，如果硬要说他们具有某种联系，就只能说是它们都访问同一个FIFO文件。它解决了之前在匿名管道中出现的通信的两个进程一定是由一个共同的祖先进程启动的问题。但是为了数据的安全，我们很多时候要采用阻塞的FIFO，让写操作变成原子操作。

[Linux]: http://blog.csdn.net/ljianhui/article/details/10168031
[view plain]: http://blog.csdn.net/ljianhui/article/details/10202699#
[SouthEast]: /images/20220614/7f21175258f44ef6bd74b195e761df36.png
[Image 1]: 
[SouthEast 1]: /images/20220614/7a9b77d4111542c580237932a393905a.png