管道概念
管道是Unix中最古老的进程间通信的形式,我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”, 管道的本质是固定大小的内核缓冲区;
如:ps aux | grep httpd | awk '{print $2}'
管道限制
- 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;
- 只能用于具有共同祖先的进程(具有亲缘关系的进程)之间进行通信;通常,一个管道由一个进程创建,然后该进程调用fork,此后父、子进程之间就可应用该管道。
匿名管道pipe
#include <unistd.h>
int pipe(int fd[2]);
参数
fd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0,失败返回错误代码
管道创建
父子进程间具有相同的文件描述符,且指向同一个管道pipe,其他没有关系的进程不能获得pipe()产生的两个文件描述符,也就不能利用同一个管道进行通信。
利用管道进行父子进程间数据传输
示例一:子进程向管道中写数据,父进程从管道中读出数据
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
pid_t pid;
pid = fork();
if(pid == -1){
perror("fork error");
exit(EXIT_FAILURE);
}
if(pid == 0){
close(fds[0]);//子进程关闭读端
write(fds[1],"hello",5);
exit(EXIT_SUCCESS);
}
close(fds[1]);//父进程关闭写端
char buf[10] = {0};
read(fds[0],buf,10);
printf("receive datas = %s\n",buf);
return 0;
}
利用管道实现ls |wc –w功能
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
pid_t pid;
pid = fork();
if(pid == -1){
perror("fork error");
exit(EXIT_FAILURE);
}
if(pid == 0){
dup2(fds[1],STDOUT_FILENO);//复制文件描述符且指定新复制的fd为标准输出
close(fds[0]);//子进程关闭读端
close(fds[1]);
execlp("ls","ls",NULL);
fprintf(stderr,"exec error\n");
exit(EXIT_FAILURE);
}
dup2(fds[0],STDIN_FILENO); //复制管道的读端,即将STDIN_FILENO作为读端
close(fds[1]);//父进程关闭写端
close(fds[0]);
execlp("wc","wc","-w",NULL);
fprintf(stderr, "error execute wc\n");
exit(EXIT_FAILURE);
}
ls | wc -w
首先将标准输出重定向到管道的写端,这样ls参数的数据就被写进管道中,然后将标准输入重定向到管道的读端吗,这样wc -w 就可以读取管道中的数据。
匿名管道读写规则
1.当没有数据可读时
O_NONBLOCK disable:read调用阻塞,即进程暂停执行,一直等到有数据来到为止。
O_NONBLOCK enable:read调用返回-1,errno值为EAGAIN。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
pid_t pid;
pid = fork();
if(pid == -1){
perror("fork error");
exit(EXIT_FAILURE);
}
if(pid == 0){
close(fds[0]);//子进程关闭读端
sleep(10);
write(fds[1],"hello",5);
exit(EXIT_SUCCESS);
}
close(fds[1]);//父进程关闭写端
char buf[10] = {0};
read(fds[0],buf,10);
printf("receive datas = %s\n",buf);
return 0;
}
管道创建时默认打开了文件描述符,且默认是阻塞(block)模式打开。所以这里,我们让子进程先睡眠10s,父进程因为没有数据从管道中读出,被阻塞了,直到子进程睡眠结束,向管道中写入数据后,父进程才读到数据
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
pid_t pid;
pid = fork();
if(pid == -1){
perror("fork error");
exit(EXIT_FAILURE);
}
if(pid == 0){
close(fds[0]);//子进程关闭读端
sleep(10);
write(fds[1],"hello",5);
exit(EXIT_SUCCESS);
}
close(fds[1]);//父进程关闭写端
char buf[10] = {0};
int flags = fcntl(fds[0], F_GETFL);//先获取原先的flags
fcntl(fds[0],F_SETFL,flags | O_NONBLOCK);//设置fd为阻塞模式
int ret;
ret = read(fds[0],buf,10);
if(ret == -1){
perror("read error");
exit(EXIT_FAILURE);
}
printf("receive datas = %s\n",buf);
return 0;
}
此时出错
2.当管道满的时候
O_NONBLOCK disable: write调用阻塞,直到有进程读走数据
O_NONBLOCK enable:调用返回-1,errno值为EAGAIN
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
int ret;
int count = 0;
while(1){
ret = write(fds[1],"A",1);//fds[1]默认是阻塞模式
if(ret == -1){
perror("write error");
break;
}
count++;
}
return 0;
}
fd打开时默认是阻塞模式,当pipe缓冲区满时,write操作确实阻塞了,等待其他进程将数据从管道中取走
下面设置非阻塞 O_NONBLOCK enable:调用返回-1,errno值为EAGAIN
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
int ret;
int count = 0;
int flags = fcntl(fds[1],F_GETFL);
fcntl(fds[1],F_SETFL,flags|O_NONBLOCK);
while(1){
ret = write(fds[1],"A",1);//fds[1]默认是阻塞模式
if(ret == -1){
perror("write error");
break;
}
count++;
}
printf("the pipe capcity is = %d\n",count);
return 0;
}
3.如果所有管道写端对应的文件描述符被关闭,则read返回0
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int fds[2];
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
pid_t pid;
pid = fork();
if(pid == -1){
perror("fork error");
exit(EXIT_FAILURE);
}
if(pid == 0){
close(fds[1]);//子进程关闭写端
exit(EXIT_SUCCESS);
}
close(fds[1]);//父进程关闭写端
char buf[10] = {0};
int ret;
ret = read(fds[0],buf,10);
printf("ret = %d\n", ret);
return 0;
}
可知确实返回0,表示读到了文件末尾,并不表示出错
4.如果所有管道读端对应的文件描述符被关闭,则write操作会产生信号SIGPIPE,断开的管道错误
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
void sighandler(int signo);
int main(void)
{
int fds[2];
if(signal(SIGPIPE,sighandler) == SIG_ERR)
{
perror("signal error");
exit(EXIT_FAILURE);
}
if(pipe(fds) == -1){
perror("pipe error");
exit(EXIT_FAILURE);
}
pid_t pid;
pid = fork();
if(pid == -1){
perror("fork error");
exit(EXIT_FAILURE);
}
if(pid == 0){
close(fds[0]);//子进程关闭读端
exit(EXIT_SUCCESS);
}
close(fds[0]);//父进程关闭读端
sleep(1);//确保子进程也将读端关闭
int ret;
ret = write(fds[1],"hello",5);
if(ret == -1){
printf("write error\n");
}
return 0;
}
void sighandler(int signo)
{
printf("catch a SIGPIPE signal and signum = %d\n",signo);
}
5.当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。
当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。
管道的容量可以从例2中看到
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
#define TEST_SIZE 68*1024
int main(void)
{
char a[TEST_SIZE];
char b[TEST_SIZE];
char c[TEST_SIZE];
memset(a, 'A', sizeof(a));
memset(b, 'B', sizeof(b));
memset(c, 'C', sizeof(c));
int pipefd[2];
int ret = pipe(pipefd);
if (ret == -1)
ERR_EXIT("pipe error");
pid_t pid;
pid = fork();
if (pid == 0)//第一个子进程
{
close(pipefd[0]);
ret = write(pipefd[1], a, sizeof(a));
printf("apid=%d write %d bytes to pipe\n", getpid(), ret);
exit(0);
}
pid = fork();
if (pid == 0)//第二个子进程
{
close(pipefd[0]);
ret = write(pipefd[1], b, sizeof(b));
printf("bpid=%d write %d bytes to pipe\n", getpid(), ret);
exit(0);
}
pid = fork();
if (pid == 0)//第三个子进程
{
close(pipefd[0]);
ret = write(pipefd[1], c, sizeof(c));
printf("bpid=%d write %d bytes to pipe\n", getpid(), ret);
exit(0);
}
close(pipefd[1]);
sleep(1);
int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
char buf[1024*4] = {0};
int n = 1;
while (1)
{
ret = read(pipefd[0], buf, sizeof(buf));
if (ret == 0)
break;
printf("n=%02d pid=%d read %d bytes from pipe buf[4095]=%c\n", n++, getpid(), ret, buf[4095]);
write(fd, buf, ret);
}
return 0;
}
可见各子进程间出现穿插写入,并没保证原子性写入,且父进程在子进程边写时边读。
PIPE_BUF
POSIX.1-2001 says that write(2)s of less than PIPE_BUF bytes must be
atomic: the output data is written to the pipe as a contiguous
sequence. Writes of more than PIPE_BUF bytes may be nonatomic: the
kernel may interleave the data with data written by other processes.
POSIX.1-2001 requires PIPE_BUF to be at least 512 bytes. (On Linux,
PIPE_BUF is 4096 bytes.) The precise semantics depend on whether the
file descriptor is nonblocking (O_NONBLOCK), whether there are
multiple writers to the pipe, and on n, the number of bytes to be
written:
O_NONBLOCK disabled, n <= PIPE_BUF
All n bytes are written atomically; write(2) may block if
there is not room for n bytes to be written immediately
阻塞模式时且n<PIPE_BUF:写入具有原子性,如果没有足够的空间供n个字节全部写入,则阻塞直到有足够空间将n个字节全部写入管道
O_NONBLOCK enabled, n <= PIPE_BUF
If there is room to write n bytes to the pipe, then write(2)
succeeds immediately, writing all n bytes; otherwise write(2)
fails, with errno set to EAGAIN.
非阻塞模式时且n<PIPE_BUF:写入具有原子性,立即全部成功写入,否则一个都不写入,返回错误
O_NONBLOCK disabled, n > PIPE_BUF
The write is nonatomic: the data given to write(2) may be
interleaved with write(2)s by other process; the write(2)
blocks until n bytes have been written.
阻塞模式时且n>PIPE_BUF:不具有原子性,可能中间有其他进程穿插写入,直到将n字节全部写入才返回,否则阻塞等待写入
O_NONBLOCK enabled, n > PIPE_BUF
If the pipe is full, then write(2) fails, with errno set to
EAGAIN. Otherwise, from 1 to n bytes may be written (i.e., a
"partial write" may occur; the caller should check the return
value from write(2) to see how many bytes were actually
written), and these bytes may be interleaved with writes by
other processes.
非阻塞模式时且N>PIPE_BUF:如果管道满的,则立即失败,一个都不写入,返回错误,如果不满,则返回写入的字节数为1~n,即部分写入,写入时可能有其他进程穿插写入
管道容量(65536)不一定等于PIPE_BUF(4K)