linux 匿名管道缓冲大小 sigpipe,Linux管道(匿名PIPE)
管道基本概念
管道是Unix中最古老的进程间通信的形式。
我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”
如:ps aux | grep httpd | awk '{print $2}'
管道示意图
管道的本质
固定大小的内核缓冲区
管道限制
1)管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道;
2)匿名管道只能用于具有共同祖先的进程(如父进程与fork出的子进程)之间进行通信;[通常，一个管道由一个进程创建，然后该进程调用fork，此后父子进程共享该管道]
匿名管道pipe
SYNOPSIS
#include
int pipe(int pipefd[2]);
功能
创建无名管道
参数
Pipefd:文件描述符数组,其中pipefd[0]表示读端,pipefd[1]表示写端
管道创建示意图
//自己实现管道
void err_exit(string str);
int main()
{
int pipefd[2];
if (pipe(pipefd) == -1)
err_exit("pipe error");
pid_t pid;
if ((pid = fork()) < 0)
err_exit("fork error");
if (pid == 0) //In Child, Write pipe
{
close(pipefd[0]);
//使得STDOUT_FILENO也指向pipefd[1],亦即ls命令的输出将打印到管道中
dup2(pipefd[1],STDOUT_FILENO);
//此时可以关闭管道写端
close(pipefd[1]);
execlp("/bin/ls","/bin/ls",NULL);
//如果进程映像替换失败,则打印下面出错信息
fprintf(stderr,"Child: execlp error");
exit(0);
}
//In Parent
close(pipefd[1]);
//使得STDIN_FILENO也指向pipefd[2],亦即wc命令将从管道中读取输入
dup2(pipefd[0],STDIN_FILENO);
//此时可以关闭管道读端
close(pipefd[0]);
execlp("/usr/bin/wc","/usr/bin/wc","-w",NULL);
//如果进程映像替换失败,则打印下面出错信息
fprintf(stderr,"Parent: execlp error");
return 0;
}
void err_exit(string str)
{
perror(str.c_str());
exit(EXIT_FAILURE);
}
示例:管道编程实践void err_exit(string str);
int main()
{
int pipefd[2];
int ret;
if ((ret = pipe(pipefd)) != 0)
{
err_exit("pipe error");
}
pid_t pid = fork();
if (pid == -1)
{
err_exit("fork error");
}
if (pid == 0) //In Child, Write pipe
{
close(pipefd[0]); //Close Read pipe
string str("I Can Write Pipe from Child!");
write(pipefd[1],str.c_str(),str.size()); //Write to pipe
close(pipefd[1]);
exit(0);
}
//In Parent, Read pipe
close(pipefd[1]); //Close Write pipe
char buf[1024];
memset(buf,0,sizeof(buf));
read(pipefd[0],buf,sizeof(buf)); //Read from pipe
cout << "Read from pipe: " << buf << endl;
close(pipefd[0]);
return 0;
}
void err_exit(string str)
{
perror(str.c_str());
exit(EXIT_FAILURE);
}
匿名管道读写规则
1)管道空时
O_NONBLOCKdisable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
2)管道满时
O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
3)管道不停被写,写满
O_NONBLOCK disable： write调用阻塞(Block)
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN//示例:设置父进程Unblock读PIPE
int main()
{
int pipefd[2];
int ret;
if ((ret = pipe(pipefd)) != 0)
{
err_exit("pipe error");
}
pid_t pid = fork();
if (pid == -1)
{
err_exit("fork error");
}
if (pid == 0) //In Child, Write pipe
{
sleep(10);
close(pipefd[0]); //Close Read pipe
string str("I Can Write Pipe from Child!");
write(pipefd[1],str.c_str(),str.size()); //Write to pipe
close(pipefd[1]);
exit(0);
}
//In Parent, Read pipe
close(pipefd[1]); //Close Write pipe
char buf[1024];
memset(buf,0,sizeof(buf));
//Set Read pipefd UnBlock!
int flags = fcntl(pipefd[0],F_GETFL);
flags |= O_NONBLOCK;
ret = fcntl(pipefd[0],F_SETFL,flags);
if (ret != 0)
{
err_exit("Set UnBlock error");
}
int readCount = read(pipefd[0],buf,sizeof(buf)); //Read from pipe
if (readCount < 0)
{
//read立刻返回,不再等待子进程发送数据
err_exit("read error");
}
cout << "Read from pipe: " << buf << endl;
close(pipefd[0]);
return 0;
}
4)如果所有管道写端对应的文件描述符被关闭，则read返回0int main()
{
int pipefd[2];
int ret;
if ((ret = pipe(pipefd)) != 0)
{
err_exit("pipe error");
}
pid_t pid = fork();
if (pid == -1)
{
err_exit("fork error");
}
if (pid == 0) //In Child
{
//close all
close(pipefd[0]);
close(pipefd[1]);
exit(0);
}
//In Parent
sleep(1);
close(pipefd[1]); //Close Write pipe, Now all pipefd[1] Closed!!!
char buf[1024];
memset(buf,0,sizeof(buf));
int readCount = read(pipefd[0],buf,sizeof(buf)); //Read from pipe
if (readCount == 0)
{
cout << "OK, read 0 byte" << endl;
}
close(pipefd[0]);
return 0;
}
5)如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPEvoid onSignalAction(int signalNumber)
{
switch(signalNumber)
{
case SIGPIPE:
cout << "receive signal SIGPIPE: " << signalNumber << endl;
break;
default:
cout << "other signal" << endl;
break;
}
}
int main()
{
if (signal(SIGPIPE,onSignalAction) != 0)
{
err_exit("signal error");
}
int pipefd[2];
int ret;
if ((ret = pipe(pipefd)) != 0)
{
err_exit("pipe error");
}
pid_t pid = fork();
if (pid == -1)
{
err_exit("fork error");
}
if (pid == 0) //In Child, Write pipe
{
//Wait Parent Close pipefd[0]
sleep(1);
close(pipefd[0]);
string str("I Can Write Pipe from Child!");
write(pipefd[1],str.c_str(),str.size()); //Write to pipe
close(pipefd[1]);
exit(0);
}
//In Parent, Close All Pipe
close(pipefd[1]);
close(pipefd[0]);
wait(NULL);
return 0;
}
Linux PIPE特征
1)当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性。
2)当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。
//示例:测试PIPE_BUF大小
int main()
{
int pipefd[2];
int ret = pipe(pipefd);
if (ret < 0)
{
err_exit("pipe error");
}
int flags = fcntl(pipefd[1],F_GETFL);
flags |= O_NONBLOCK;
ret = fcntl(pipefd[1],F_SETFL,flags);
if (ret < 0)
{
err_exit("fcntl error");
}
//Write test
unsigned int countForTestPipe = 0;
while (true)
{
ret = write(pipefd[1],"a",1);
if (ret < 0)
{
break;
}
++ countForTestPipe;
}
cout << "size = " << countForTestPipe << endl;
}
/**测试结果:Ubuntu 14.04 X64
xiaofang@xiaofang-Lenovo-G470:~/apue/it$ ./main
size = 65536
*/
附-管道容量查询
man 7 pipe
附-深入理解文件描述符int main()
{
close(STDIN_FILENO);
if (open("readfile.txt",O_RDONLY) == -1)
{
err_exit("open read error");
}
close(STDOUT_FILENO);
if (open("writefile.txt",O_WRONLY|O_TRUNC|O_CREAT,0644) == -1)
{
err_exit("open write error");
}
if (execlp("/bin/cat","/bin/cat",NULL) == -1)
{
err_exit("execlp error");
}
return 0;
}