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

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

 

1、什么是命名管道

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

 

因为Linux中全部的事物均可被视为文件，因此对命名管道的使用也就变得与文件操做很是的统一，也使它的使用很是方便，同时咱们也能够像日常的文件名同样在命令中使用。

 

2、建立命名管道

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

 

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename, mode_t mode);
int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0);

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

 

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

 

3、访问命名管道

 

一、打开FIFO文件

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

 

可是有两点要注意，一、就是程序不能以O_RDWR模式打开FIFO文件进行读写操做，而其行为也未明肯定义，由于如一个管道以读/写方式打开，进程就会读回本身的输出，同时咱们一般使用FIFO只是为了单向的数据传递。二、就是传递给open调用的是FIFO的路径名，而不是正常的文件。

 

打开FIFO文件一般有四种方式，

 

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

在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也不会被打开。

 

4、使用FIFO实现进程间的通讯

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

 

fifowrite.c的源代码以下：

 

#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>

int main()
{
    const char *fifo_name = "/tmp/my_fifo";
    int pipe_fd = -1;
    int data_fd = -1;
    int res = 0;
    const int open_mode = O_WRONLY;
    int bytes_sent = 0;
    char buffer[PIPE_BUF + 1];

    if(access(fifo_name, F_OK) == -1)
    {
        //管道文件不存在
        //建立命名管道
        res = mkfifo(fifo_name, 0777);
        if(res != 0)
        {
            fprintf(stderr, "Could not create fifo %s\n", fifo_name);
            exit(EXIT_FAILURE);
        }
    }

    printf("Process %d opening FIFO O_WRONLY\n", getpid());
    //以只写阻塞方式打开FIFO文件，以只读方式打开数据文件
    pipe_fd = open(fifo_name, open_mode);
    data_fd = open("Data.txt", O_RDONLY);
    printf("Process %d result %d\n", getpid(), pipe_fd);

    if(pipe_fd != -1)
    {
        int bytes_read = 0;
        //向数据文件读取数据
        bytes_read = read(data_fd, buffer, PIPE_BUF);
        buffer[bytes_read] = '\0';
        while(bytes_read > 0)
        {
            //向FIFO文件写数据
            res = write(pipe_fd, buffer, bytes_read);
            if(res == -1)
            {
                fprintf(stderr, "Write error on pipe\n");
                exit(EXIT_FAILURE);
            }
            //累加写的字节数，并继续读取数据
            bytes_sent += res;
            bytes_read = read(data_fd, buffer, PIPE_BUF);
            buffer[bytes_read] = '\0';
        }
        close(pipe_fd);
        close(data_fd);
    }
    else
        exit(EXIT_FAILURE);

    printf("Process %d finished\n", getpid());
    exit(EXIT_SUCCESS);
}

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

 

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <string.h>

int main()
{
    const char *fifo_name = "/tmp/my_fifo";
    int pipe_fd = -1;
    int data_fd = -1;
    int res = 0;
    int open_mode = O_RDONLY;
    char buffer[PIPE_BUF + 1];
    int bytes_read = 0;
    int bytes_write = 0;
    //清空缓冲数组
    memset(buffer, '\0', sizeof(buffer));

    printf("Process %d opening FIFO O_RDONLY\n", getpid());
    //以只读阻塞方式打开管道文件，注意与fifowrite.c文件中的FIFO同名
    pipe_fd = open(fifo_name, open_mode);
    //以只写方式建立保存数据的文件
    data_fd = open("DataFormFIFO.txt", O_WRONLY|O_CREAT, 0644);
    printf("Process %d result %d\n",getpid(), pipe_fd);

    if(pipe_fd != -1)
    {
        do
        {
            //读取FIFO中的数据，并把它保存在文件DataFormFIFO.txt文件中
            res = read(pipe_fd, buffer, PIPE_BUF);
            bytes_write = write(data_fd, buffer, res);
            bytes_read += res;
        }while(res > 0);
        close(pipe_fd);
        close(data_fd);
    }
    else
        exit(EXIT_FAILURE);

    printf("Process %d finished, %d bytes read\n", getpid(), bytes_read);
    exit(EXIT_SUCCESS);
}

 

运行结果以下：

 

分析：两个程序都使用阻塞模式的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，能够看到以下结果：

 

 

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

 

5、命名管道的安全问题

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

 

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

 

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

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

 

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