进程间通信-管道

管道

管道是针对于本地计算机的两个进程之间的通信而设计的通信方法，管道建立后，实际上是获得两个文件描述符：一个用与读取而另一个用于写入。任何从管道写入端写入的数据，可以从管道读取端读出。

管道具有以下特点：

• 管道是一种半双工通信机制，即数据只能在一个方向上流动，不能同时进行双向数据传输。一个进程可以将数据写入管道，另一个进程则可以从管道读取数据，但不能同时进行双向通信。需要双向通信时，要建立起两个管道。
• 管道是一种特殊的文件系统，进程通过文件描述符进行读写操作，实现数据传输。

管道分类：

• 匿名管道
• 命名管道

匿名管道

匿名管道又称为无名管道，用于父子进程之间进行通信。匿名管道没有在文件系统中创建文件，而是通过内存进行数据传输。

pipe() 函数用于创建一个管道，该函数定义如下：

#include <unistd.h>

int pipe(int [2]);

参数说明

• pipefd：接受一个整型数组作为参数，数组包含两个文件描述符，pipefd[0] 为管道的读取端，pipefd[1] 为管道的写入端。

返回值

• 如果函数执行成功，返回值为0。
• 如果函数执行失败，返回值为-1，可以通过 errno 变量来获取具体的错误信息。

原理

在单个进程中使用管道几乎没有任何意义。通常情况下，父进程先调用 pipe() 函数创建一条管道，再通过 fork() 函数创建子进程。子进程在创建时，会拷贝父进程的文件描述符表。之后父进程关闭 读（写）端，子进程关闭 写（读）端，从而建立一条父子进程间通信的通道。流程如下图所示：

示例

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<signal.h>
#include<errno.h>

void childWrite(int fds[2])
{
    close(fds[0]);
    char buf[1024];
    int i = 0;
    while(1)
    {
        sprintf(buf, "Child Data%d", i++);
        int nRet = write(fds[1], buf, strlen(buf));
        if(nRet == -1)
        {
            perror("write");
            exit(1);
        }

        printf("child write %d bytes\n", nRet);
        sleep(1);
    }
    close(fds[1]);
}

void parentRead(int fds[2])
{
    close(fds[1]);
    char buf[1024];
    while(1)
    {
        int nRet = read(fds[0], buf, sizeof(buf) - 1);
        if(nRet == -1)
        {
            perror("read");
            exit(1);
        }
        buf[nRet] = '\0';
        printf("parent read : %s\n", buf);
        sleep(1);
    }
}

int main(int argc, char** argv)
{

    int fds[2];
    if(pipe(fds) == -1)
    {
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid == -1)
    {
        perror("fork");
        return -1;
    }
    else if(pid == 0)
        childWrite(fds);
    else
        parentRead(fds);

    return 0;
}

输出：

child write 11 bytes
parent read : Child Data0
child write 11 bytes
parent read : Child Data1
child write 11 bytes
parent read : Child Data2
...

获取管道最大容量

void childWrite(int fds[2])
{
    close(fds[0]);
    char buf[1024];
    int i = 0;
    while(1)
    {
        write(fds[1], "1", 1);
        printf("write count : %d\n",++i);
    }
    close(fds[1]);
}

void parentRead(int fds[2])
{
    close(fds[1]);
    while(1);
}

上述代码中，写端每次向管道中写入1个字节，之后输出当前写入的个数。读端不做任何处理，输出如下：

write count : 1
...
write count : 65536
                        //阻塞

可以发现，管道的默认大小为64KB，可以通过 ulimit -a 命令查看：

$ ulimit -a
...
pipe size            (512 bytes, -p) 8
...

总结

• 匿名管道只能用于父子进程或者兄弟进程之间。
• 当前读端关闭，写端继续写入，管道会破裂，将产生 SIGPIPE 信号，该信号会导致进程退出。同时， write() 函数返回-1，errno 被设置为 EPIPE。
• 当前写端关闭，读端会将管道中数据读取完，再次读取时，read函数返回0，表示写端已经关闭。
• 读写端都未关闭，当管道写满时，再次写入数据，write() 函数会被阻塞。
• 读写端都未关闭，当管道为空时，再次读取数据，read() 函数会被阻塞。

命名管道

命名管道是一种特殊类型的文件，被称为管道文件。与普通文件不同，管道文件不会再磁盘上分配数据块，是通过内存进行数据传输。对管道的操作与对普通文件的操作类似，都是通过文件描述符进行访问。进程通过向管道中写入数据或从管道中读取数据来进行通信。

命名管道的特点：

• 可以在不相关的进程之间进行通信，只要它们可以访问同一个管道文件。
• 数据传输是单向的，一个进程向管道写入数据，另一个进程从管道读取数据。
• 数据传输是基于字节流，没有消息边界。
• 命名管道会一直保持存在，不受进程退出影响，直到被显式地删除。

对于管道文件的创建，可以使用 mkfifo 命令或 mkfifo() 函数来创建命名管道，mkfifo 命令格式如下：

mkfifo [选项] <管道名称>

• 选项：通常情况下不需要任何选项
• 管道名称：指定要创建的命名管道的路径和名称。

mkfifo() 函数定义如下：

#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

参数说明

• pathname：要创建的命名管道文件的路径名。
• mode：用于设置文件权限的参数，类似于 chmod() 函数中所使用的参数。

返回值

如果函数执行成功，返回值为0。如果函数执行失败，返回值为-1，并且可以通过 errno 变量来获取具体的错误信息。常见错误值如下：

• EEXIST：创建的文件已经存在。
• ENAMETOOLONG：路径名太长。
• EACCES：权限不足，无法创建命名管道。

通过 mkfifo 命令或 mkfifo() 函数创建管道，管道文件信息如下：

$ stat myFifo 
  文件：myFifo
  大小：0             块：0          IO 块：4096   先进先出
设备：805h/2053d    Inode：1192546     硬链接：1
权限：(0664/prw-rw-r--)  Uid：( 1000/ test)   Gid：( 1000/ test)
...

$ ls -l myFifo 
prw-rw-r-- 1 test test 0 8月  21 14:17 myFifo

通过open函数打开管道文件时，可能会发送阻塞行为，只有当两边的管道都打开的时，open函数才会返回。例如：

#include<stdio.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>

int main(int argc, char** argv)
{
    int nRet = mkfifo("./myfifo", 0666);
    if(nRet == -1)
    {
        if(errno != EEXIST)
        {
            perror("mkfifo");
            return -1;
        }
    }
    
    printf("create fifo success!\n");
    
    int fd = open("./myfifo", O_WRONLY);
    if(fd == -1)
    {
        perror("open");
        return -1;
    }
    
    printf("open fd success!\n");
    return 0;
}

输出：

create fifo success!
            //阻塞

从输出结果来看，函数阻塞在 open() 函数位置。

示例：

fifowrite.c

#include<stdio.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<signal.h>

void sigHandler(int sig)
{
    printf("signal : %d\n", sig);
}

int main(int argc, char** argv)
{
    signal(SIGPIPE, sigHandler);

    if(mkfifo("./myfifo", 0666) == -1)
    {
        if(errno != EEXIST)
        {
            perror("mkfifo");
            return -1;
        }
    }    

    int fd = open("./myfifo", O_WRONLY);
    char buf[32] = {0};
    int i = 0;
    while(1)
    {
        sprintf(buf, "Data%d", ++i);
        int nRet = write(fd, buf, strlen(buf));
        if(nRet == -1)
        {
            perror("write");
            return -1;
        }
        sleep(1);
    }

    return 0;
}

fiforead.c

#include<stdio.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>

int main(int argc, char** argv)
{
    if(mkfifo("./myfifo", 0666) == -1)
    {
        if(errno != EEXIST)
        {
            perror("mkfifo");
            return -1;
        }
    }    

    int fd = open("./myfifo", O_RDONLY);
    char buf[32] = {0};
    while(1)
    {
        int nRet = read(fd, buf, sizeof(buf) - 1);
        if(nRet == -1)
        {
            perror("read");
            return 0;
        }
        else if(nRet == 0)
        {
            printf("pipe has closed!\n");
            return 0;
        }
        printf("read : %s\n", buf);
        sleep(1);
    }

    return 0;
}