2.2、进程通信之管道通信

1、管道简介

　　管道是Linux中进程间通信的一种方式，他把一个程序的输出直接连接到另一个程序的输入。Linux的管道主要包括两种：无名管道和有名管道。

　　管道不属于进程的资源，而是和套接字一样，属于操作系统（也就不是fork函数的复制对象）。所以，两个进程通过操作系统提供的内存空间进行通信。

　　1.1、无名管道

　　无名管道是Linux中管道通信的一种原始方法，如下图所示，它具有如下特点：

　　（1）它只能用于具有亲缘关系的进程之间的通信（也就是父子进程或者兄弟进程之间）。

　　（2）它是一个单工的通信模式，具有固定的读端和写端（单工：读写端是固定的，一边只能读，一边只能写）。

　　（3）管道也可以看成是一种特殊的文件，对于它的读写也可以使用普通的read()、write()等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

 1.2、有名管道

　　有名管道是对无名管道的一种改进，如下图所示，它具有如下特点：

　　（1）它可以使互不相关的两个进程实现彼此通信。

　　（2）该管道可以通过路径名来指出，并且在文件系统中是可见的。在建立了管道之后，两个进程就可以把它当做普通文件一样进行读写操作，使用非常方便。

　　（3）FIFO严格地遵循先进先出规则，对管道及FIFO的读总是从开始处返回数据，对它们的写则是把数据添加到末尾，它们不支持如lseek()等文件定位操作。

 2、无名管道系统调用

　　2.1、无名管道创建与关闭

　　无名管道是基于文件描述符的通信方式。当一个无名管道建立时，它会创建两个文件描述符fd[0]和fd[1]，关闭管道时也会将两个文件描述符都关闭。其中fd[0]固定用于读管道，而fd[1]固定用于写管道，如下图所示，这样就构成了一个单工的数据通道。

　　 管道关闭时只需将这两个文件描述符关闭即可，可使用普通的close()函数逐个关闭各个文件描述符。

　　2.2、无名管道创建函数

　　 创建管道可以通过调用pipe()来实现，pipe()创建的管道两端在一个进程中。

头文件	#include <unistd.h>
函数原型	int pipe(int fd[2]);
作用	创建无名管道
参数	fd[2]	管道的两个文件描述符，之后就可以直接操作这两个文件描述符，一个出口，一个入口
返回值	成功	0
	失败	-1

 　　向管道传递数据时，先读的进程会把数据取走，简而言之，数据进入管道后成为无主数据。也就是通过read函数先读取数据的进程将得到数据，即使该进程将数据传到了管道。

　　两个进程间通信可以创建两个管道，各自负责不同的数据流动即可。

　　2.3．无名管道读写说明

　　 用pipe()函数创建的管道两端处于一个进程中，由于管道是主要用于在不同进程间通信的，因此在实际应用中没有太大意义。实际上，通常先是创建一个管道，再调用fork()函数创建一个子进程，该子进程会继承父进程所创建的管道，这时，父子进程管道的文件描述符对应关系如下图所示。

　　需要注意的是，无名管道是单工的工作方式，即进程要么只能读管道，要么只能写管道。父子进程虽然都拥有管道的读端和写端，但是只能使用其中一个（例如，可以约定父进程读管道，而子进程写管道），这样就应该把不使用的读端或写端的文件描述符关闭。例如在下图中将父进程的写端fd[1]和子进程的读端fd[0]关闭。此时，父子进程之间就建立起了一条“子进程写入父进程读取”的通道。

　　此时的关系看似非常复杂，实际上却已经给不同进程之间的读写创造了很好的条件。父子进程分别拥有自己的读写通道，为了实现父子进程之间的读写，只需把无关的读端或写端的文件描述符关闭即可。例如，在下图中将父进程的写端fd[1]和子进程的读端fd[0]关闭。此时，父子进程之间就建立起了一条“子进程写入父进程读取”的通道。

　　同样，也可以关闭父进程的fd[0]和子进程的fd[1]，这样就可以建立一条“父进程写入子进程读取”的通道。另外，父进程还可以创建多个子进程，各个子进程都继承了相应的fd[0]和fd[1]。这时，只需关闭相应端口就可以建立其各子进程间的通道。

　　2.4、无名管道读写注意点

　　（1）当管道中无数据时，独读操作会阻塞

　　（2）只有在管道的读端存在时，向管道写入数据才有意义。否则，向管道写入数据的进程将收到内核传来的SIGPIPE信号（通常为Broken pipe错误）。

　　（3） 向管道写入数据时，Linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读取管道缓冲区中的数据，那么写操作将会一直阻塞。

　　（4）父子进程在运行时，它们的先后次序并不能保证。因此，为了保证父子进程已经关闭了相应的文件描述符，可在两个进程中调用sleep()函数。当然这种调用不是很好的解决方法，在后面学到进程之间的同步机制与互斥机制后，请读者自行修改本小节的实例程序。

　　2.5、使用实例

　　在本例中，首先创建管道，之后父进程使用fork()函数创建子进程，后通过关闭父进程的读描述符和子进程的写描述符，建立起它们之间的管道通信。

/* pipe.c */
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX_DATA_LEN    256
#define DELAY_TIME    1

int main()
{
　　pid_t pid;
　　int pipe_fd[2];
　　char buf[MAX_DATA_LEN];
　　const char data[] = "Pipe Test Program";
　　int real_read, real_write;

　　memset((void*)buf, 0, sizeof(buf));
　　if (pipe(pipe_fd) < 0) /* 创建管道 */
　　{
　　　　printf("pipe create error\n");
　　　　exit(1);
　　}
　　if ((pid = fork()) == 0) /* 创建一个子进程 */
　　{
　　　　/* 子进程关闭写描述符，并通过使子进程暂停1s等待父进程已关闭相应的读描述符 */
　　　　close(pipe_fd[1]);
　　　　sleep(DELAY_TIME * 3);
　　　　/* 子进程读取管道内容 */
　　　　if ((real_read = read(pipe_fd[0], buf, MAX_DATA_LEN)) > 0)
　　　　{
　　　　　　printf("%d bytes read from the pipe is '%s'\n", real_read, buf);
　　　　}
　　　　close(pipe_fd[0]); /* 关闭子进程读描述符 */
　　　　exit(0);
　　}
　　else if (pid > 0)
　　{
　　　　/* 父进程关闭读描述符，并通过使父进程暂停1s等待子进程已关闭相应的写描述符 */
　　　　close(pipe_fd[0]);
　　　　sleep(DELAY_TIME);
　　　　if((real_write = write(pipe_fd[1], data, strlen(data))) != -1)
　　　　{
　　　　　　printf("Parent wrote %d bytes : '%s'\n", real_write, data);
　　　　}
　　　　close(pipe_fd[1]); /* 关闭父进程写描述符 */
　　　　waitpid(pid, NULL, 0); /* 收集子进程退出信息 */
　　　　exit(0);
　　}
}

将该程序交叉编译，下载到开发板上的运行结果如下：
$ ./pipe
Parent wrote 17 bytes : 'Pipe Test Program'
17 bytes read from the pipe is 'Pipe Test Program

 

3、有名管道（FIFO）

　　有名管道的创建可以使用函数mkfifo()，该函数类似于文件中的open()操作，可以指定管道的路径和打开的模式（用户还可以在命令行使用“mknod 管道名 p”来创建有名管道）。

　　有名管道可以使互不相关的两个进程互相通信，有名管道可以通过路径名来指出，并且在文件系统中可见。

　　在创建管道成功后，就可以使用open()、read()和write()这些函数了。与普通文件的开发设置一样，对于为读而打开的管道可在open()中设置O_RDONLY，对于为写而打开的管道可在open()中设置O_WRONLY，在这里与普通文件不同的是阻塞问题。由于普通文件在读写时不会出现阻塞问题，而在管道的读写中却有阻塞的可能，这里的非阻塞标志可以在open()函数中设定为O_NONBLOCK。下面分别对阻塞打开和非阻塞打开的读写进行讨论。

　　进程通过文件IO来操作有名管道，有名管道遵循先进先出规则。

　　不支持如lseek()操作。

　　3.1、对于读进程

　　（1）若该管道是阻塞打开，且当前FIFO内没有数据，则对读进程而言将一直阻塞到有数据写入或是FIFO写端都被关闭。

　　（2）若该管道是非阻塞打开，则不论FIFO内是否有数据，读进程都会立即执行读操作。即如果FIFO内没有数据，则读函数将立刻返回0。

　　（3）缺省情况下，如果当前FIFO内没有数据，读进程将一直阻塞到有数据写入或是FIFO写端都被关闭。

　　3.2、对于写进程

　　（1）若该管道是阻塞打开，则写操作将一直阻塞到数据可以被写入。

　　（2）若该管道是非阻塞打开而不能写入全部数据，则读操作进行部分写入或者调用失败。

　　（3）只要FIFO有空间，数据就可以被写入。若空间不足，写进程会阻塞，直到数据都写入为止

头文件	#include <sys/types.h> #include <sys/state.h>
函数原型	int mkfifo(const char *filename,mode_t mode);
作用	创建有名管道
	filename	要创建的管道
	mode	O_RDONLY：读管道 O_WRONLY：写管道 O_RDWR：读写管道 O_NONBLOCK：非阻塞 O_CREAT：如果该文件不存在，那么就创建一个新的文件，并用第3个参数为其设置权限 O_EXCL：如果使用O_CREAT时文件存在，那么可返回错误消息。这个参数可测试文件是否存在
返回值	成功	0
	失败	-1

 

EACCESS	参数filename所指定的目录路径无可执行的权限
EEXIST	参数filename所指定的文件已存在
ENAMETOOLONG	参数filename的路径名称太长
ENOENT	参数filename包含的目录不存在
ENOSPC	文件系统的剩余空间不足
ENOTDIR	参数filename路径中的目录存在但却非真正的目录
EROFS	参数filename指定的文件存在于只读文件系统内

 

下面的实例包含两个程序，一个用于读管道，另一个用于写管道。其中在读管道的程序中创建管道，并且作为main()函数里的参数由用户输入要写入的内容；读管道的程序会读出用户写入到管道的内容。这两个程序采用的是阻塞式读写管道模式。

写管道的程序如下：
/* fifo_write.c */
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MYFIFO    "/tmp/myfifo"    /* 有名管道文件名 */
#define MAX_BUFFER_SIZE    PIPE_BUF /* 定义在limits.h中 */

int main(int argc, char * argv[]) /* 参数为即将写入的字符串 */
{
　　int fd;
　　char buff[MAX_BUFFER_SIZE];
　　int nwrite;

　　if(argc <= 1)
　　{
　　　　printf("Usage: ./fifo_write string\n");
　　　　exit(1);
　　}
　　sscanf(argv[1], "%s", buff);

　　/* 以只写阻塞方式打开FIFO管道 */
　　fd = open(MYFIFO, O_WRONLY);
　　if (fd == -1)
　　{
　　　　printf("Open fifo file error\n");
　　　　exit(1);
　　}

　　/* 向管道中写入字符串 */
　　if ((nwrite = write(fd, buff, MAX_BUFFER_SIZE)) > 0)
　　{
　　　　printf("Write '%s' to FIFO\n", buff);
　　}
　　close(fd);
　　exit(0);
}

 

读管道的程序如下：
/* fifo_read.c */

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MYFIFO    "/tmp/myfifo"    /* 有名管道文件名 */
#define MAX_BUFFER_SIZE    PIPE_BUF /* 定义在limits.h中 */

int main()
{
　　char buff[MAX_BUFFER_SIZE];
　　int fd;
　　int nread;

　　/* 判断有名管道是否已存在，若尚未创建，则以相应的权限创建 */
　　if (access(MYFIFO, F_OK) == -1) 
　　{
　　　　if ((mkfifo(MYFIFO, 0666) < 0) && (errno != EEXIST))
　　　　{
　　　　　　printf("Cannot create fifo file\n");
　　　　　　exit(1);
　　　　}
　　}
　　/* 以只读阻塞方式打开有名管道 */
　　fd = open(MYFIFO, O_RDONLY);
　　if (fd == -1)
　　{
　　　　printf("Open fifo file error\n");
　　　　exit(1);
　　}

　　while (1)
　　{
　　　　memset(buff, 0, sizeof(buff));
　　　　if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0)
　　　　{
　　　　　　printf("Read '%s' from FIFO\n", buff);
　　　　}    
　　}    
　　close(fd);    
　　exit(0);
}

　　为了能够较好地观察运行结果，需要把这两个程序分别在两个终端里运行，在这里首先启动读管道程序。读管道进程在建立管道后就开始循环地从管道里读出内容，如果没有数据可读，则一直阻塞到写管道进程向管道写入数据。在启动了写管道程序后，读进程能够从管道里读出用户的输入内容，程序运行结果如下。

终端一：
$ ./fifo_read
Read 'FIFO' from FIFO
Read 'Test' from FIFO
Read 'Program' from FIFO
…

终端二：
$ ./fifo_write FIFO
Write 'FIFO' to FIFO
$ ./fifo_write Test
Write 'Test' to FIFO
$ ./fifo_write Program
Write 'Program' to FIFO
…