管道:
是一种最基本的IPC机制,作用于有血缘关系的进程之间,完成数据传递。
调用pipe系统函数即可创建一个管道。
特质:
1. 其本质是一个伪文件(实为内核缓冲区)
2. 由两个文件描述符引用,一个表示读端,一个表示写端。
3. 规定数据从管道的写端流入管道,从读端流出。
原理:
管道实为内核使用环形队列机制,借助内核缓冲区(4k)实现。
局限性:
①数据不能进程自己写,自己读。
②管道中数据不可反复读取。一旦读走,管道中不再存在。
③采用半双工通信方式,数据只能在单方向上流动。
④只能在有公共祖先的进程间使用管道。
管道的读写行为:
① 读管道:
1. 管道中有数据,read返回实际读到的字节数。
2. 管道中无数据:
1) 管道写端被全部关闭,read返回0 (类似读到文件结尾)
2) 写端没有全部被关闭,read阻塞等待 (不久的将来可能有数据递达,此时会让出cpu)
② 写管道:
1. 管道读端全部被关闭, 进程异常终止(也可使用捕捉SIGPIPE信号,使进程不终止)
2. 管道读端没有全部关闭:
1) 管道已满,write阻塞。
2) 管道未满,write将数据写入,并返回实际写入的字节数。
pipe:
pipe函数:
创建,并打开管道
int pipe ( int pipefd[2] );
成功:0; 失败:-1,设置errno
参数:
fd[0] → r读端; fd[1] → w写端
就像0对应标准输入,1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。
案例一: 管道的基本用法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
int main(int argc, char *argv[])
{
int ret;
int fd[2];
pid_t pid;
char *str = "hello pipe\n";
char buf[1024];
ret = pipe(fd);
if(ret == -1){
sys_err("pipe error");
}
pid = fork();
if(pid > 0){
close(fd[0]); // 父进程关闭读端
write(fd[1], str, strlen(str));
sleep(1);
close(fd[1]);
} else if (pid ==0){
close(fd[1]); // 子进程关闭写端
ret = read(fd[0], buf, sizeof(buf));
write(STDOUT_FILENO, buf, ret);
close(fd[0]);
}
return 0;
}
案例二:父子进程通信
练习:使用管道实现父子进程间通信,完成:ls | wc –l。假定父进程实现ls,子进程实现wc。
ls命令正常会将结果集写出到stdout,但现在会写入管道的写端;
wc –l 正常应该从stdin读取数据,但此时会从管道的读端读。
问题: 程序执行,发现程序执行结束,shell还在阻塞等待用户输入。这是因为,shell → fork → ./pipe, 程序pipe的子进程将stdin重定向给管道,父进程执行的ls会将结果集通过管道写给子进程。若父进程在子进程打印wc的结果到屏幕之前被shell调用wait回收,shell就会先输出$提示符。
解决: 让父进程读,子进程写,这样父进程一定比子进程后结束
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
int main(int argc, char *argv[])
{
int fd[2];
int ret;
pid_t pid;
ret = pipe(fd); //父进程先创建一个管道,持有管道的读写端
if(ret == -1){
sys_err("pipe error");
}
pid = fork(); //子进程同样持有读端和写端
if(pid == -1){
sys_err("fork error");
} else if(pid > 0){
close(fd[1]); // 父进程 读, 关闭写端
dup2(fd[0],STDIN_FILENO); // 重定向 stin 到管道的 读端
execlp("wc", "wc", "-l", NULL); // 执行 wc -l 程序
sys_err("exclp wc error");
} else if(pid == 0){
close(fd[0]);
dup2(fd[1],STDOUT_FILENO); // 重定向 stdout 到管道写端
execlp("ls", "ls", NULL); // 子进程 执行 ls 命令
sys_err("exclp ls error");
}
return 0;
}
案例三: 兄弟进程通信
练习:使用管道实现兄弟进程间通信。 兄:ls 弟: wc -l 父:等待回收子进程。
要求: 使用“循环创建N个子进程”模型创建兄弟进程,使用循环因子i标示。注意管道读写行为。
测试:是否允许,一个pipe有一个写端,多个读端呢? 允许
是否允许有一个读端多个写端呢?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <pthread.h>
void sys_err(const char *str)
{
perror(str);
exit(1);
}
int main(int argc, char *argv[])
{
int fd[2];
int ret, i;
pid_t pid;
ret = pipe(fd);
if(ret == -1){
sys_err("pipe error");
}
for(i = 0; i < 2; i++){ // 表达式2 出口,仅限父进程
pid = fork();
if(pid == -1){
sys_err("fork error");
}
if(pid == 0){ // 子进程 出口
break;
}
}
if(i == 2){ //父进程 不参与 管道使用
close(fd[0]); // 关闭管道的 读端/写端
close(fd[1]);
wait(NULL); // 回收子进程
wait(NULL);
} else if(i == 0){ // 兄进程
close(fd[0]);
dup2(fd[1],STDOUT_FILENO); // 重定向 stdout
execlp("ls", "ls", NULL);
sys_err("exclp ls error");
} else if(i == 1){ //弟进程
close(fd[1]);
dup2(fd[0],STDIN_FILENO); // 重定向 stdin
execlp("wc", "wc", "-l", NULL);
sys_err("exclp wc error");
}
return 0;
}
管道缓冲区大小
ulimit –a :
查看当前系统中创建管道文件所对应的内核缓冲区大小。
通常为:
pipe size (512 bytes, -p) 8
fpathconf函数:
借助参数选项来查看。使用该宏应引入头文件<unistd.h>
long fpathconf(int fd, int name);
成功:返回管道的大小
失败:-1,设置errno
FIFO
FIFO常被称为命名管道,以区分管道(pipe)。
管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO,不相关的进程也能交换数据。
FIFO是Linux基础文件类型中的一种。
但,FIFO文件在磁盘上没有数据块,仅仅用来标识内核中一条通道。
各进程可以打开这个文件进行read/write,实际上是在读写内核通道,这样就实现了进程间通信。
创建方式:
1. 命令:mkfifo 管道名
2. 库函数:int mkfifo(const char *pathname, mode_t mode); 成功:0; 失败:-1
一旦使用mkfifo创建了一个FIFO,就可以使用open打开它,常见的文件I/O函数都可用于fifo。如:close、read、write、unlink等。