Linux进程间通信(IPC)编程实践（二） FIFO命名管道

左手的ㄟ右手 2022-05-14 05:58 202阅读 0赞

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

#    1 什么是命名管道 #

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

由于Linux中所有的事物都可被视为文件，所以对命名管道的使用也就变得与文件操作非常的统一，也使它的使用非常方便，同时我们也可以像平常的文件名一样在命令中使用。FIFO只是借用了文件系统(file system,命名管道是一种特殊类型的文件，因为Linux中所有事物都是文件，它在文件系统中以文件名的形式存在。)来为管道命名。写模式的进程向FIFO文件中写入，而读模式的进程从FIFO文件中读出。当删除FIFO文件时，管道连接也随之消失。FIFO的好处在于我们可以通过文件的路径来识别管道，从而让没有亲缘关系的进程之间建立连接。

#    2 创建一个命名管道 #

#include <sys/types.h>
    #include <sys/stat.h>
    #include <stdio.h>
    
    // int mkfifo(const char *pathname, mode_t mode);
    
    // 实例
    int main()
    {
        if (mkfifo("p2", 0644) == -1)
        {
            printf("mkfifo error");
            return -1;
        }
    
        return 0;
    }

mknod函数也可以创建一个命名管道，但是mknod是比较老的函数，而使用mkfifo函数更加简单和规范，所以建议在可能的情况下，尽量使用mkfifo而不是mknod。

#    3 FIFO与PIPE的区别 #

(1) 匿名管道由pipe函数创建并打开。  
    命名管道由mkfifo函数创建，打开用open。

(2) FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一旦这些工作完成之后，它们具有相同的语义。

# 4 打开FIFO文件 #

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

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

打开FIFO文件通常有4种方式：

open(const char *path, O_RDONLY);               // 1  
    open(const char *path, O_RDONLY | O_NONBLOCK);  // 2  
    open(const char *path, O_WRONLY);               // 3  
    open(const char *path, O_WRONLY | O_NONBLOCK);  // 4

![70][]

# 5 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对拷数据:利用管道,两个进程间进行文件复制。

#    6 实例 #

## 6.1 进程writefifo ##

(1)读文件(文件名从命令行参数中获取)

(2)写入管道myFifo(管道由该进程创建)

(3)关闭文件及管道

// 1:writefifo  
    
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdio.h>
    #include <fcntl.h>
    
    int main(int argc, char *argv[])  
    {  
        if (argc < 2)
        {    
            printf("Usage: ./writefifo <read-file-name>");
            return -1;
        }
      
        // 创建管道  
        if (mkfifo("myFifo", 0644) == -1)
        {
            printf("mkfifo error");
            return -1;
        }
        
        int outfd = open("myFifo", O_WRONLY);   // 打开FIFO
        int infd = open(argv[1], O_RDONLY);     // 打开文件
        if (outfd == -1 || infd == -1)
        {
            printf("open file/fifo error");
            if(-1 != infd)
            {
                close(infd);  
            }
            if(-1 != outfd)
            {
                close(outfd);
            }
            return -1;
        }
      
        char buf[BUFSIZ] = {0};  
        int readBytes = 0;  
        while ((readBytes = read(infd, buf, sizeof(buf))) > 0)  
        {  
            write(outfd, buf, readBytes);  
        }
        
        close(infd);  
        close(outfd);
        
        return 0;
    }

##    6.2 进程readfifo ##

(1)读管道myFifo

(2)写入文件\[该文件有进程创建并打开\]

(3)关闭文件

(4)删除管道

// 2:readfifo
    
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdio.h>
    #include <fcntl.h>
    
    int main(int argc, char *argv[])  
    {  
        if (argc < 2)
        {
            printf("Usage: ./writefifo <write-file-name>");
            return -1;
        }
      
        int outfd = open(argv[1], O_WRONLY|O_CREAT|O_TRUNC, 0644);  // 创建并打卡文件
        int infd = open("myFifo", O_RDONLY);                        // 打开FIFO
        if (infd == -1 || outfd == -1)
        {
            printf("open file/fifo error");
            if(-1 != infd)
            {
                close(infd);  
            }
            if(-1 != outfd)
            {
                close(outfd);
            }
            return -1;
        }
      
        char buf[BUFSIZ] = {0};  
        int readBytes = 0;  
        while ((readBytes = read(infd, buf, sizeof(buf))) > 0)  
        {  
            write(outfd, buf, readBytes);  
        }  
      
        close(outfd);
        close(infd);
        unlink("myFifo");   // 删除FIFO
        
        return 0;
    }

## 6.3 分析 ##

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

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

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

**本文转自：**

**[https://blog.csdn.net/NK\_test/article/details/48677145][https_blog.csdn.net_NK_test_article_details_48677145]**

[70]: /images/20220514/3ed54db0b69d495ca6c3e94786561cd4.png
[https_blog.csdn.net_NK_test_article_details_48677145]: https://blog.csdn.net/NK_test/article/details/48677145