管道是一种只允许用在有亲属关系的进程间通信的方式，由函数pipe创建一个管道，read,write进行读写操作。
#include <unistd.h>
int pipe(int pipefd[]);
参数pipefd[2]数组返回打开的读写描述符，pipefd[0]为读，pipefd[1]为写。
第一个问题:文件描述符怎么会出现一个只能读，一个只能写呢?猜想是对一个文件打开了2次，一个以只读打开，一个以只写打开。使用fcntl来验证下:
#include <unistd.h>
#include <fcntl.h> int fcntl(int fd, int cmd, ... /* arg */ );
F_GETFL (void)
Get the file access mode and the file status flags; arg is ignored.
cmd为F_GETFL时，最后一个参数arg被忽略。测试代码:
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h> int main(void)
{
int flags;
int fd[]; if (pipe(fd) < )
{
perror("pipe error");
} flags = fcntl(fd[], F_GETFL,);
if ( flags < )
{
perror("fcntl");
close(fd[]);
close(fd[]);
}
switch (flags & O_ACCMODE)
{
case O_RDONLY:
printf("read only\n");
break; case O_WRONLY:
printf("write only\n");
break; case O_RDWR:
printf("read write\n");
break; default:
printf("unknown access mode\n");
} flags = fcntl(fd[], F_GETFL,);
if ( flags < )
{
perror("fcntl");
close(fd[]);
close(fd[]);
}
switch (flags & O_ACCMODE)
{
case O_RDONLY:
printf("read only\n");
break; case O_WRONLY:
printf("write only\n");
break; case O_RDWR:
printf("read write\n");
break; default:
printf("unknown access mode\n");
}
close(fd[]);
close(fd[]);
exit();
}
运行结果:
read only
write only
与猜想相符。
数据的流向:
从图中可以看出，进程可以以pipefd[1]写完，然后以pipefd[0]读，自己写自己读，这条数据流是通的。 验证:
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h> #define MAXLINE 4096
int main(void)
{
int flags;
int fd[], n;
char buf[MAXLINE];
if (pipe(fd) < )
{
perror("pipe error");
} n = write(fd[], "hello world\n", MAXLINE);
if ( n < )
{
perror("write");
goto end;
}
n = read(fd[],buf, n);
if ( n < )
{
perror("read");
goto end;
}
printf("read:%s\n",buf); end:
close(fd[]);
close(fd[]);
exit();
}
输出:
read:hello world
既然是进程间通信，那么管道在同一个进程中读写基本是没什么意义的，管道常用的方式是，先创建一个管道，然后fork，父子进程就共享了这个管道了。数据流向如图:
这样，管道的写端有2个进程操作，读端有2个进程操作。但是这样一来就出现了一个问题，假设父进程读，那么这个数据是它自己写进去的呢？还是子进程写进去的？无法区分。通常一个进程关闭它的读，另一个进程关闭它的写，这样，数据流向就只有一个方向了，数据来自谁就显而易见了。如图:
测试代码:
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h> #define MAXLINE 4096 int main(void)
{
int n;
int fd[];
pid_t pid;
char line[MAXLINE]; if (pipe(fd) < )
perror("pipe error");
if ((pid = fork()) < )
{
perror("fork error");
}
else if (pid > ) /* parent */
{
close(fd[]);
write(fd[], "hello world\n", );
}
else /* child */
{
close(fd[]);
n = read(fd[], line, MAXLINE);
write(STDOUT_FILENO, line, n);
}
exit();
}
结果:
hello world
读一个空的管道或者写一个满的管道都将导致阻塞，不过可以通过fcntl的F_SETFL设置为O_NONBLOCK，从而不阻塞。
当管道一端被关闭后，有下列2条规则：
1.当读一个写端所有文件描述符引用都已被关闭的管道时，在所有数据被读完后，read将返回0。表示无数据可读。
2.当写一个读端所有文件描述符引用都已被关闭的管道时，将产生SIGPIPE信号，write返回-1。
混淆的东西，管道的容量和管道的缓冲区大小。
管道的容量：指管道满时装的字节数，自2.6.11内核后，容量为64k。管道满了就会导致写操作产生阻塞。
管道缓冲区大小：由PIPE_BUF指定，指的是保证管道写操作为原子操作的最大值，如果一次写入的内容超过这个值，那么这次的写操作就不是原子的。什么意思呢？就是指，可能存在多个进程写同一个管道，如果一次写入的字节数大于缓冲区大小，则可能会出现A进程写入的内容中插入了B进程写入的内容。
下面是出现这种情况的代码:
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h> #define MAXLINE 4096+100 int main(void)
{
int n;
int fd[];
pid_t pid;
char line[MAXLINE]; if (pipe(fd) < )
{
perror("pipe error");
} if ((pid = fork()) < )
{
perror("fork error");
}
else if (pid > ) /* parent */
{
close(fd[]);
while ( )
{
n = read(fd[], line, MAXLINE);
write(STDOUT_FILENO, line, n);
write(STDOUT_FILENO, "\n\n\n", );
}
}
else /* child */
{
if ((pid = fork()) < )
{
perror("fork error");
}
else if (pid > )
{
close(fd[]); while ()
{
memset(line, 'a',MAXLINE);
write(fd[], line, MAXLINE);
}
}
else
{
close(fd[]); while ( )
{
memset(line, 'b',MAXLINE);
write(fd[], line, MAXLINE);
}
}
} exit();
}