管道是一种最基本的IPC方式，本文以笔记形式以及典型程序来描述管道的特点。

1.管道特点关键字

• 半双工通信
• 亲缘进程间通信
• 内存中的特殊文件
• 在末尾写数据，在头部读数据

2.管道创建

先创建管道，再创建进程。即先pipe，再fork。

3.从管道中读数据

• 管道的写端不存在，那么进程认为已经读到了数据的末尾，读函数返回的字节数为0。
• 这里有三个名词：PIPE_BUF，请求读取字节数（request_num）,管道中数据量（pipe_num）;那么关于这三个量之间的关系如下图。

下面这个程序可以加深你对上述读规则的理解，实现代码如下：

int main()
{
	int fd[2];
	int ret,request;
	char rbuf[4096];
	char wbuf[5000];
	char *msg="hello,pipe!",*msg2="hello,I come here ,too!";
	pid_t pid;
	int stat_val;

	if(pipe(fd)\<\0)
	{
		printf("pipe error\n");
		exit(1);
	}

	if((pid=fork())==0)
	{
		//child process write
		close(fd[0]);
		ret=write(fd[1],msg,strlen(msg)+1);
		printf("I am writer and I write %d Byte data\n",ret);
          	sleep(5);
		ret=write(fd[1],msg2,strlen(msg2)+1);
		printf("I am writer and I write %d Byte data\n",ret);
		sleep(5);
		close(fd[1]);
		exit(0);
	}
	else if(pid\>\0)
	{
		//parent process read
		close(fd[1]);
		request=5000;
		ret=read(fd[0],rbuf,request);
		printf("when reader request %d Byte,the actual return Bytes is %d\n",request,ret);
		request=10;
		ret=read(fd[0],rbuf,request);
		printf("when reader requesr %d Byte,the actual return Bytes is %d\n",request,ret);
		request=100;
		ret=read(fd[0],rbuf,request);
		printf("when reader request %d Byte,the actual return Bytes is %d\n",request,ret);
		request=1;
		ret=read(fd[0],rbuf,request);
		printf("when reader request %d Byte,the actual return Bytes is %d\n",request,ret);
		close(fd[0]);
		exit(0);
	}
}

该程序中父进程读数据，子进程去写数据。至于运行过程请你亲自去尝试，因为我觉得我在这里说的多么具体，都不及你亲自去感受。

首先你可能会想：是否应该在父进程所要执行的代码前加一个sleep(1)?因为在父进程读之前，管道内至少得有数据啊！其实可以不用加。因为如果管道内无数据可读，父进程自动阻塞，直至有数据或者不存在写端时才会继续运行。

在子进程第一次写操作后，就睡眠5秒，此时父进程刚好读完管道内的所有数据，因为请求的数据量为5000，而PIPE_BUF为4960。现在管道内已经无数据可读了，因此父进程阻塞。5秒过后，子进程继续写入24Byte。父进程第二次请求10Byte，因此根据上述我们所说的读规则，read函数返回10。父进程第三次请求读100Byte的数据，根据上述读规则，他将返回管道内所有数据的字节数，因此read函数返回14Byte。

父进程第四次请求读前，管道已经空了，按照我们刚所说的，父进程现在应该阻塞了。因此在子进程睡眠5秒后，父进程发现读端已经关闭，因此读函数返回0。

4.从管道中写数据

• 只有管道读端存在时，管道写数据才有意义。
• 写数据时，Linux不能保证写入的原子性。

关于写数据的第一条规则，很好去验证，比如上述程序，如果在父进程一开始就关闭两个端，那么子进程将会自动退出。但是如果将子进程的读端不关闭，那么子进程是可以正常写入pipe的。因此，在写管道时，应该至少保证一个进程的的读端是打开的。

关于写数据的非原子性是指，如果要写入A字节的数据，而此时管道内只有B字节的缓冲区，而且A>B。那么此时写端的进程就会分批写入数据：先写入B字节，然后再写入(A-B)字节。特殊的，当A-B仍然大于PIPE_BUF的时候，那么还是先写PIPE_BUF字节，然后再写(A-B-PIPE_BUF)字节的数据。如果当前在写入最后一批数据前，可以一次性写入管道，那么此时写函数将返回写入的字节数，而不是等所有数据都写完毕后再返回写入的字节数。

下面这个程序请务必亲自动手验证。

int main()
{
	int fd[2];
	int ret,request;
	char rbuf[50000];
	char wbuf[65000];
	char wbuf2[100000];
	char *msg="hello,pipe!",*msg2="hello,I come here ,too!";
	pid_t pid;
	int stat_val;

	if(pipe(fd)\<\0)
	{
		printf("pipe error\n");
		exit(1);
	}

	if((pid=fork())==0)
	{
		//child process write
		close(fd[0]);
		ret=write(fd[1],wbuf,65000);
		printf("I am writer and I write %d Byte data\n",ret);
		ret=write(fd[1],wbuf2,100000);
		printf("I am writer and I write %d Byte data\n",ret);
		printf("writer has over\n");
		close(fd[1]);
		exit(0);
	}
	else if(pid\>\0)
	{
		//parent process read
//		sleep(3);
		close(fd[1]);
		while(1)
		{
			sleep(1);
			ret=read(fd[0],rbuf,10000);
			printf("I am reader and the num of reading data is %d\n",ret);
		}
		close(fd[0]);
		exit(0);
	}
}

在程序运行后，当第七次显示已经读了10000字节时，就说明了写管道时的非原子性。因为如果写是原子性的，即便先写入的65000字节被读走，那么也不可能一次性全部写入100000字节（因为PIPE_BUF为65536）。当第七次提示已读入10000字节时，说明先将一部分数据写入了管道内的空闲区，否则第七次读入提示只显示已读入5000字节。 当第11次读入提示显示后，就会接着显示已写入100000字节的提示。因为前11次读中：先用7次（第七次的10000字节中既有第一次写入的5000字节，又有第二次的一部分数据）读走了第一次写入的65000字节，然后用5次读走第二次要写入100000字节的前45000字节，当剩余65000字节时，已经可以一次性写入管道，因此在最后一次写之前返回写入的字节数100000。这与上述我们概述的原理符合。

以上解释需要多次实验和斟酌。

5.管道的局限性关键词

• 单向流动
• 缓冲区局限性
• 亲缘进程间通信局限性
• 字符流传送

对于管道半双工流动的特点，如果使用两条管道，那么就可以实现两个进程间全双工通信。具体例子《LinuxC编程实战》一书中有详解。不过我这里想特别说明的是，由于管道的读端在无数据可读时会自动阻塞，因此如果两个管道都首先进行读数据，那么此程序会发生死锁，因为父子进程都在等待数据的出现（当然它们等待的管道不同）。因此解决的办法是父子进程都先去写数据或和一个先读一个先写。

对于管道的另一个应用，就是父进程创建子进程后向子进程传递参数（具体可见《实战》P250）。对于这个应用，下面仅说明如何传递。运行监控端程序时，会输入相应的参数（argv[1]）,父进程将其写入管道。按照以往的读管道规则，子进程直接从管道读就可以了，但是在本应用中，子程序会去执行一个新的程序（ctrlpocess.c）。我们知道子进程在执行exec函数后，它的“前身”除了pid，几乎一点都不留。所以此刻在新进程中我们直接使用fd[0],fd[1]显然不行。

现在该如何解决？我们既要从管道中读数据，还得保证有一个可用的文件描述符。显然我们应该在子进程“离别”前（执行exec前）将读端（fd[0]）定向到标准输入端。这样子进程在执行新的程序时就可以在标准出入端读数据了。

最后需要说明的是，本文仅仅阐述了管道部分的基本知识点，要深入理解管道则需要多次实践。毕竟实践出真知。