存在一个问题 示例4:/*父进程与子进程之间交互:父进程向子进程写入from parent process,子进程向父进程写入from child process*/
参考文章
0.序
进程之间的通信 IPC:
进程之间通信实际上就是进程之间进行消息传递。
管道可用于具有亲缘关系进程间的通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。
管道是Linux支持的最初Unix IPC形式之一,具有以下特点:
管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;
只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);
单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中。
数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据。
管道两端用描述字fd[0]以及fd[1]来描述,管道的两端是固定了任务的。fd[0]只能用于读,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。
1.两条重要规则:
当管道的一端被关闭后,下列两条规则起作用:
1)当读一个写端被关闭的管道时,所有数据都被读取后,read返回0,用于指示达到了文件结束处。
2)当写一个读端被关闭的管道,则产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回,则write返回-1,errno设置为EPIPE。
2.从管道中读取数据
1)如果管道的写端不存在,读完管道中现有的所有数据后,则认为已经读到了数据的末尾,读函数返回的读出字节数为0;
2)如果管道的写端存在并且有数据,那么就返回管道中现有的数据字节数或者请求的字节数。
当管道的写端存在时,如果请求的字节数目大于PIPE_BUF,则返回管道中现有的数据字节数;如果请求的字节数目不大于PIPE_BUF,则返回管道中现有数据字节数(此时,管道中数据量小于请求的数据量);或者返回请求的字节数(此时,管道中数据量不小于请求的数据量)。
3)如果管道没有数据,且管道的写端口是打开状态,则读操作被阻塞直到有数据写入为止。
3.向管道中写入数据:
对于设置了阻塞标志的写操作:
(1)当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数,则进入睡眠,直到当缓冲区中能够容纳要写入的字节数时,才开始进行一次性写操作。
(2)当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域,写进程就会试图向管道写入数据,写操作在写完所有请求写的数据后返回。
对于没有设置阻塞标志的写操作:
(1)当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后,写操作返回。
(2)当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数,写完后成功返回;如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数,则返回EAGAIN错误,提醒以后再写.
4.管道的局限性
管道的主要局限性正体现在它的特点上:
只支持单向数据流;
只能用于具有亲缘关系的进程之间;
没有名字;
管道的缓冲区是有限的(管道制存在于内存中,在管道创建时,为缓冲区分配一个页面大小);
管道所传送的是无格式字节流,这就要求管道的读出方和写入方必须事先约定好数据的格式,比如多少字节算作一个消息(或命令、或记录)等等;
有名管道以FIFO的文件形式存在于文件系统中。这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信
5.学习用例:
为了充分理解管道,现在又从网上找到部分详细用例
示例1:
/*1 只有管道写端的引用计数变成0,才会关闭管道得写端.
2 进程结束后,自动关闭打开的文件
3 如果父进程先退出,而且没有调用wait等待子进程, 那么子进程就会变成僵死进程*/
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, const char **argv)
{
int len;
pid_t pid;
int pfd[2];
char buffer[1024] = {0};
if (pipe(pfd) < 0) {
printf("pipe error\n");
exit(0);
}
if ((pid = fork()) < 0) {
printf("fork error\n");
exit(0);
}
if (pid == 0) { /* 子进程 */
write(pfd[1], "hello\n", 6);
// close(pfd[1]);
sleep(2);
} else { /* 父进程 */
close(pfd[1]);
while ((len = read(pfd[0], buffer, 1023)) > 0) {
buffer[len] = '\0';
printf("len = %d, %s", len, buffer);
}
printf("read done\n");
wait(0); /* 等待子进程退出才能看到效果 */
}
return 0;
} |
示例2:
/* 如果父进程不关闭管道的写端, 即便子进程关闭了管道的写端, 还是会阻塞在read上
1)当读一个写端被关闭的管道时,所有数据都被读取后,read返回0,用于指示达到了文件结束处
这个程序可以很好地说明这一点,当注释掉parent中close(pfd[1]);后,程序就进入阻塞*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main(int argc, const char **argv)
{
int len;
pid_t pid;
int pfd[2];
char buffer[1024] = {0};
if (pipe(pfd) < 0) {
printf("pipe error\n");
exit(0);
}
if ((pid = fork()) < 0) {
printf("fork error\n");
exit(0);
}
if (pid == 0) { /* 子进程 */
close(pfd[1]);
while ((len = read(pfd[0], buffer, 1023)) > 0) {
buffer[len] = '\0';
printf("len = %d, %s", len, buffer);
}
} else { /* 父进程 */
close(pfd[0]);
write(pfd[1], "hello\n", 6);
// close(pfd[1]);
wait(0);
}
return 0;
} |
示例3:
/* 当写一个读端被关闭的管道,则产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回,则write返回-1,errno设置为EPIPE。
当用gdb运行时,可以发现当写一个读端被关闭的管道,会产生信号SIGPIPE*/
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#define MAXLINE 200
int main(void)
{
int n;
int fd[2];
pid_t pid;
char line[MAXLINE];
if(pipe(fd) < 0)
printf("pipe error\n");
if((pid = fork()) < 0)
printf("fork error\n");
else if(pid > 0 ){
close(fd[0]);
while(1){
n = write(fd[1],"hello,world",MAXLINE);
if(n <= 0){
printf("n <= 0\n");
break;
}
printf("parent n :%d\n",n);
}
waitpid(pid,0,0);
}else{
printf("child\n");
close(fd[1]);
n = read(fd[0],line,MAXLINE);
write(STDOUT_FILENO,line,n);
close(fd[0]);
printf("close read end in child\n");
}
exit(0);
} |
gdb运行结果
示例4:
/*父进程与子进程之间交互:父进程向子进程写入from parent process,子进程向父进程写入from child process*/
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, const char **argv)
{
int pfd2[2];
pid_t pid;
int pfd1[2];
int n;
char buffer1[1024] = {0}; char buffer2[1024] = {0}
if ( (pipe(pfd1) < 0) || (pipe(pfd2) < 0) ) {
printf("pipe error\n");
exit(0);
}
if ((pid = fork()) < 0) {
printf("fork error\n");
exit(0);
}
if (pid == 0) { /* 子进程 */
close(pfd1[0]);
write(pfd1[1],"from child process",1024);
close(pfd1[1]);
close(pfd2[1]);
while((n = read(pfd2[0],buffer1,1024)) > 0 )
write(STDOUT_FILENO,buffer1,n);
exit(1);
} else { /* 父进程 */
close(pfd2[0]);
write(pfd2[1],"from parent process",1024);
close(pfd2[1]);
close(pfd1[1]);
while((n = read(pfd1[0],buffer2,1024)) > 0 )
write(STDOUT_FILENO,buffer2,n);
wait(0);
}
return 0;
} |
运行结果:不知道为什么会出现两次from parent process
示例5:
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, const char **argv)
{
int pfd2[2];
pid_t pid;
int pfd1[2];
int n;
char buffer1[1024] = {0},buffer2[1024]={0};
if ( (pipe(pfd1) < 0) || (pipe(pfd2) < 0) ) {
printf("pipe error\n");
exit(0);
}
if ((pid = fork()) < 0) {
printf("fork error\n");
exit(0);
}
if (pid == 0) { /* 子进程 */
close(pfd1[0]);
write(pfd1[1],"from child process",1024);
close(pfd1[1]);
close(pfd2[1]);
while((n = read(pfd2[0],buffer1,1024)) > 0 ){
buffer1[n]='\0';
printf("buffer1:%s\n",buffer1);
}
exit(1);
} else { /* 父进程 */
close(pfd1[1]);
close(pfd2[0]);
write(pfd2[1],"from parent process",1024);
close(pfd2[1]);
while((n = read(pfd1[0],buffer2,1024)) > 0 ){
buffer2[n]='\0';
printf("buffer2:%s\n",buffer2);
}
wait(0);
}
return 0;
} |
6.总结
管道:用于进程间通信。
管道有其局限性:1)半双工性 2) 只能在拥有共同祖先的进程间进行通信
管道的读写操作:
1)管道读操作:(1)正常读取 (2)读取写端关闭的通道,那么在读取完所有数据以后,会返回0,表示文件结束
2)管道写操作:(1)正常写 (2)写入读端关闭的通道,那么会产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回,则write返回-1,errno设置为EPIPE。