管道是Linux支持的最初Unix IPC形式之一，具有以下特点：
**管道是半双工的，数据只能向一个方向流动，一端输入，另一端输出。需要双方通信时，需要建立起两个管道。
**管道分为普通管道和命名管道。普通管道位于内存，只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）。命名管道位于文件系统，没有亲缘关系的进程间只要知道管道名也可以通讯。
**管道也是文件。管道大小为4096字节。
**单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在于内存中。
**数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
**管道满时，写阻塞；管道空时，读阻塞。
管道只能在有亲缘关系的进程间使用。这是由于管道没有名字的原因，所以不能跨进程的地址空间进行使用。这里这句话不是绝对的，因为从技术上可以在进程间传递管道的描述符，所以是可以通过管道实现无亲缘进程间的通信的。但尽管如此，管道还是通常用于具有共同祖先的进程间的通信。
#include <unistd.h>
int pipe(int filedest[2]) //成功返回0，失败返回-1
pipe函数用来创建一个管道，fd是传出参数，用于保存返回的两个文件描述符，该文件描述符用于标识管道的两端，fd[0]只能用于读，fd[1]只能用于写。
那么如果我们往fd[0]端写数据会是什么样的结果呢?
下面是测试代码：
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <errno.h>
int main()
{
int fd[2];
if (pipe(fd) < 0)
{
std::cout<<"create pipe failed."<<std::endl;
return -1;
}
char *temp = "hello world";
if (write(fd[0], temp, strlen(temp) + 1) < 0)
{
std::cout<<"write pipe failed:"<<strerror(errno)<<std::endl;
}
return 0;
}输出结果：从这个结果可以看出，内核对于管道的fd[0]描述符打开的方式是以只读方式打开的，同理fd[1]是以只写方式打开的，所以管道只能保证单向的数据通信。
下图显示的是一个进程内的管道的数据流程：
从上图我们可以看到位于内核中的管道，进程通过两个文件描述符进行数据的传输，当然单个进程内的管道是没有必要的，上面只是为了更形象的表明管道的工作方式，一般管道的使用方式都是：父进程创建一个管道，然后fork产生一个子进程，由于子进程拥有父进程的副本，所以父子进程可以通过管道进程通信。这种使用方式如下图所示：
如上图所示，当父进程通过fork创建子进程后，父子进程都拥有对管道操作的文件描述符，此时父子进程关闭对应的读写端，使父子进程间形成单向的管道。关闭哪个端要根据具体的数据流向决定。
上面说了父进程通过fork创建子进程后，父子进程间可以通过管道通信，数据流的方向根据具体的应用决定。我们都知道在shell中，管道的数据流向都是从父进程流向子进程，即父进程关闭读端，子进程关闭写端。如下图所示：
测试代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
int pfd[2]; //保存打开管道后的两个文件描述符
pid_t cpid; //保存子进程标识符
char buf;
if(argc != 2)//判断命令行参数是否符合
{
fprintf(stderr,"Usage: %s <string>\n",argv[0]);
exit(0);
}
if (pipe(pfd) == -1)//建立管道
{
perror("pipe");
exit(EXIT_FAILURE);
}
cpid = fork();
if (cpid == -1)
{
perror("fork");
exit(EXIT_FAILURE);
}
if (cpid == 0) //子进程
{
close(pfd[1]); //关闭管道写，引用计数-1
while (read(pfd[0], &buf, 1) > 0) //从管道循环读取数据
write(STDOUT_FILENO, &buf, 1); //输出读到的数据
write(STDOUT_FILENO, "\n", 1); //输出从管道读取的数据
close(pfd[0]); //关闭管道读，引用计数-1
exit(0);
}
else <span style="font-family: 宋体;">//父进程</span>
{
close(pfd[0]); //关闭管道读
write(pfd[1], argv[1], strlen(argv[1]));//向管道写入命令行参数1
close(pfd[1]);
wait(NULL); //等待子进程退出
exit(0);
}
}
说明：每调用一次fork 都要关闭一次进程描述符
执行此行命令：#./a.out www
程序输出： WWW
上述代码流程是，子进程等待父进程通过管道发送过来的数据，然后输出接收到的数据，代码中的read会阻塞到管道中有数据为止。
由上我们知道，一个管道只能支持亲缘进程间的单向通信即半双工通信。如果要想通过管道来支持双向通信呢，那这里就需要创建两个管道，fd1，fd2；父进程中关闭fd1[0]，fd2[1]，子进程中关闭fd1[1]，fd2[0]。这种通信模式如下图所示：
下面是双向通信的测试代码：
#include <iostream>
#include <unistd.h>
int main()
{
int fd1[2], fd2[2];
if (pipe(fd1) < 0 || pipe(fd2) < 0)
{
std::cout<<"create pipe failed."<<std::endl;
return -1;
}
char buf[256];
char *temp = "hello world";
if (fork() == 0)
{
close(fd1[1]);
close(fd2[0]);
read(fd1[0], buf, sizeof(buf));
std::cout<<"child:receive message from pipe 1: "<<buf<<std::endl;
write(fd2[1], temp, strlen(temp) + 1);
exit(0);
}
close(fd1[0]);
close(fd2[1]);
write(fd1[1], temp, strlen(temp) + 1);
read(fd2[0], buf, sizeof(buf));
std::cout<<"parent:receive message from pipe 2: "<<buf<<std::endl;
return 0;
}
代码的执行结果如下：
child:receive message from pipe 1: hello world
parent:receive message from pipe 2: hello world
其中代码的流程是父进程创建了两个管道，用fd1，fd2表示，管道fd1负责父进程向子进程发送数据，fd2负责子进程向父进程发送数据。进程启动后，子进程等待父进程通过管道fd1发送数据，当子进程收到父进程的数据后，输出消息，并通过管道fd2回复父进程，然后子进程退出，父进程收到子进程的响应后，输出消息并退出。
前面已经提到过对管道的read会阻塞到管道中有数据为止，具体管道的read和write的规则将会在后面介绍。
作为管道的一个实例，就是标准I/O函数库提供的popen函数，该函数创建一个管道，并fork一个子进程，该子进程根据popen传入的参数，关闭管道的对应端，然后执行传入的shell命令，然后等待终止。
调用进程和fork的子进程之间形成一个管道。调用进程和执行shell命令的子进程之间的管道通信是通过popen返回的FILE*来间接的实现的，调用进程通过标准文件I/O来写入或读取管道。
#include <stdio.h>
FILE *popen(const char *command, const char *type); //成功返回标准文件I/O指针，失败返回NULL
command：该传入参数是一个shell命令行，这个命令是通过shell处理的。
type：该参数决定调用进程对要执行的command的处理，type有如下两种情况：
type = “r”，调用进程将读取command执行后的标准输出，该标准输出通过返回的FILE*来操作；
type = “w”，调用进程将写command执行过程中的标准输入；
int pclose(FILE *stream); //成功返回shell的终止状态，失败返回-1
pclose函数会关闭由popen创建的标准I/O流，等待其中的命令终止，然后返回shell的执行状态。
下面是关于popen的测试代码1：
#include <iostream>
#include <cstdio>
#include <unistd.h>
using namespace std;
int main()
{
char *cmd = "ls /usr/include/sys*.h";
FILE *p = popen(cmd, "r");
char buf[256];
while (fgets(buf, 256, p) != NULL)
{
cout<<buf;
}
pclose(p);
return 0;
}输出：程序的执行流程如下：调用进程执行popen时，会创建一个管道，然后fork生成一个子进程，子进程执行popen传入的"ls /usr/local/bin" shell命令，子进程将执行结果通过管道传递给调用进程，调用进程通过标准文件I/O来读取管道中的数据,并输出显示。
测试代码2：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int main( void )
{
FILE *stream;//文件流
char buf[1024];//读写缓冲区
memset( buf, '\0', sizeof(buf) );//清空
stream = popen( "ls /usr/include/sys*.h", "w" );
for(;;)
{
memset(buf,0x00,sizeof(buf));
scanf("%s",buf);//接受输入
if(strcmp(buf,"k") == 0)//如果是k就退出
{
break;
}
fprintf(stream,"%s\n",buf);//写入
}
pclose( stream );//关闭
return 0;
}输出：管道两端可分别用描述字fd[0]以及fd[1]来描述，需要注意的是，管道的两端是固定了任务的。即一端只能用于读，由描述字fd[0]表示，称其为管道读端；另一端则只能用于写，由描述字fd[1]来表示，称其为管道写端。如果试图从管道写端读取数据，或者向管道读端写入数据都将导致错误发生。一般文件的I/O函数都可以用于管道，如close、read、write等等。
从管道中读取数据：
--如果管道的写端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0；
--当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。注：（PIPE_BUF在include/linux/limits.h中定义，不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节，red hat 7.2中为4096）。
向管道中写入数据：
--向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。
注意：只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号，应用程序可以处理该信号，也可以忽略（默认动作则是应用程序终止）。
对管道的写规则的验证1：写端对读端存在的依赖性
#include <unistd.h>
#include <sys/types.h>
int main()
{
int pipe_fd[2];
pid_t pid;
char r_buf[4];
char* w_buf;
int writenum;
int cmd;
memset(r_buf, 0, sizeof(r_buf));
if (pipe(pipe_fd)<0)
{
printf("pipe create error\n");
return -1;
}
if ((pid = fork()) == 0)
{
close(pipe_fd[0]);
close(pipe_fd[1]);
sleep(10);
exit();
}
else if (pid>0)
{
sleep(1); //等待子进程完成关闭读端的操作
close(pipe_fd[0]);//write
w_buf = "111";
if ((writenum = write(pipe_fd[1], w_buf, 4)) == -1)
printf("write to pipe error\n");
else
printf("the bytes write to pipe is %d \n", writenum);
close(pipe_fd[1]);
}
return 0;
}
输出：
Broken pipe
原因就是该管道以及它的所有fork()产物的读端都已经被关闭。如果在父进程中保留读端，即在写完pipe后，再关闭父进程的读端，也会正常写入pipe。因此，在向管道写入数据时，至少应该存在某一个进程，其中管道读端没有被关闭，否则就会出现上述错误（管道断裂，进程收到了SIGPIPE信号，默认动作是进程终止）。
对管道的写规则的验证2：linux不保证写管道的原子性验证
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
int main(int argc, char**argv)
{
int pipe_fd[2];
pid_t pid;
char r_buf[4096];
char w_buf[4096 * 2];
int writenum;
int rnum;
memset(r_buf, 0, sizeof(r_buf));
if (pipe(pipe_fd)<0)
{
printf("pipe create error\n");
return -1;
}
if ((pid = fork()) == 0)
{
close(pipe_fd[1]);
while (1)
{
sleep(1);
rnum = read(pipe_fd[0], r_buf, 1000);
printf("child: readnum is %d\n", rnum);
}
close(pipe_fd[0]);
exit();
}
else if (pid>0)
{
close(pipe_fd[0]);//write
memset(r_buf, 0, sizeof(r_buf));
if ((writenum = write(pipe_fd[1], w_buf, 1024)) == -1)
printf("write to pipe error\n");
else
printf("the bytes write to pipe is %d \n", writenum);
writenum = write(pipe_fd[1], w_buf, 4096);
close(pipe_fd[1]);
}
return 0;
}输出：结论：
写入数目小于4096时写入是非原子的！
如果把父进程中的两次写入字节数都改为5000，则很容易得出下面结论：
写入管道的数据量大于4096字节时，缓冲区的空闲空间将被写入数据（补齐），直到写完所有数据为止，如果没有进程读数据，则一直阻塞。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
int pfds[2];
if ( pipe(pfds) == 0 )
{
if ( fork() == 0 )//子进程
{
close(1);//关闭标准输出
dup2( pfds[1], 1 );//管道的写文件描述符复制到进程的输出
close( pfds[0] );//关闭管道读
execlp( "ls", "ls","-l", NULL );//执行ls -l 输出写入管道
}
else
{
close(0);
dup2( pfds[0], 0 );//管道的读文件描述符复制到进程的输入
close( pfds[1] );
execlp( "wc", "wc", "-l", NULL );//执行wc -l 将管道读取数据作为wc命令的输入
}
}
return 0;
}[root@MiWiFi-R1CM csdnblog]# ls -a其中Linux execlp函数相当于执行
# ls -l | wc -l
统计当前目录下文件数量
原文地址：http://blog.csdn.net/shltsh/article/details/46524401
