Linux系统编程—管道
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux系统编程—管道相关的知识，希望对你有一定的参考价值。
参考技术A Linux 实现 IPC 其中的一种方式——管道管道又分：
1、无名管道：无名管道只能用于有亲缘关系的进程。
2、有名管道：有名管道用于任意两进程间通信。
你就可以把管道理解成位于进程内核空间的“文件”。
给文件加引号，是因为它和文件确实很像，因为它也有描述符。但是它确实又不是普通的本地文件，而是一种抽象的存在。
当进程使用 pipe 函数，就可以打开位于内核中的这个特殊“文件”。同时 pipe 函数会返回两个描述符，一个用于读，一个用于写。如果你使用 fstat函数来测试该描述符，可以发现此文件类型为 FIFO。
而无名管道的无名，指的就是这个虚幻的“文件”，它没有名字。本质上，pipe 函数会在进程内核空间申请一块内存（比如一个内存页，一般是 4KB），然后把这块内存当成一个先进先出（FIFO）的循环队列来存取数据，这一切都由操作系统帮助我们实现了。
pipe 函数打开的文件描述符是通过参数（数组）传递出来的，而返回值表示打开成功（0）或失败（-1）。
它的参数是一个大小为 2 的数组。此数组的第 0 个元素用来接收以读的方式打开的描述符，而第 1 个元素用来接收以写的方式打开的描述符。也就是说，pipefd[0] 是用于读的，而 pipefd[1] 是用于写的。
打开了文件描述符后，就可以使用 read(pipefd[0]) 和 write(pipefd[1]) 来读写数据了。
注意事项
1、这两个分别用于读写的描述符必须同时打开才行，否则会出问题。
2、如果关闭读 (close(pipefd[0])) 端保留写端，继续向写端 (pipefd[1]) 端写数据(write 函数)的进程会收到 SIGPIPE 信号。
3、如果关闭写 (close(pipefd[1])) 端保留读端，继续向读端 (pipefd[0]) 端读数据(read 函数)，read 函数会返回 0。
当在进程用 pipe 函数打开两个描述符后，我们可以 fork 出一个子进程。这样，子进程也会继承这两个描述符，而且这两个文件描述符的引用计数会变成 2。
如果你需要父进程向子进程发送数据，那么得把父进程的 pipefd[0] （读端）关闭，而在子进程中把 pipefd[1] 写端关闭，反之亦然。为什么要这样做？实际上是避免出错。传统上 pipe 管道只能用于半双工通信（即一端只能发，不能收；而另一端只能收不能发），为了安全起见，各个进程需要把不用的那一端关闭（本质上是引用计数减 1）。
步骤一：fork 子进程
步骤二：关闭父进程读端，关闭子进程写端
父进程 fork 出一个子进程，通过无名管道向子进程发送字符，子进程收到数据后将字符串中的小写字符转换成大写并输出。
有名管道打破了无名管道的限制，进化出了一个实实在在的 FIFO 类型的文件。这意味着即使没有亲缘关系的进程也可以互相通信了。所以，只要不同的进程打开 FIFO 文件，往此文件读写数据，就可以达到通信的目的。
1、文件属性前面标注的文件类型是 p
2、代表管道文件大小是 0
3、fifo 文件需要有读写两端，否则在打开 fifo 文件时会阻塞
通过命令 mkfifo 创建
通过函数 mkfifo创建
函数返回 0 表示成功，-1 失败。
例如:
cat 命令打印 test文件内容
接下来你的 cat 命令被阻塞住。
开启另一个终端，执行：
然后你会看到被阻塞的 cat 又继续执行完毕，在屏幕打印 “hello world”。如果你反过来执行上面两个命令，会发现先执行的那个总是被阻塞。
有两个程序，分别是发送端 send 和接收端面 recv。程序 send 从标准输入接收字符，并发送到程序 recv，同时 recv 将接收到的字符打印到屏幕。
发送端
接收端
编译
运行
因为 recv 端还没打开test文件，这时候 send 是阻塞状态的。
再开启另一个终端：
这时候 send 端和 recv 端都在终端显示has opend fifo
此时在 send 端输入数据，recv 打印。
Linux系统编程进程间通信之无名管道
00. 目录
文章目录
01. 管道概述
管道也叫无名管道，它是是 UNIX 系统 IPC（进程间通信） 的最古老形式，所有的 UNIX 系统都支持这种通信机制。
无名管道的特点
1、半双工，数据在同一时刻只能在一个方向上流动。
2、数据只能从管道的一端写入，从另一端读出。
3、写入管道中的数据遵循先入先出的规则。
4、管道所传送的数据是无格式的，这要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。
5、管道不是普通的文件，不属于某个文件系统，其只存在于内存中。
6、管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。
7、从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据。
8、管道没有名字，只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。
对于无名管道特点的理解，我们可以类比现实生活中管子，管子的一端塞东西，管子的另一端取东西。
无名管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。
02. 管道创建函数
#include <unistd.h>
int pipe(int pipefd[2]);
功能：
创建无名管道。
参数：
pipefd : 为 int 型数组的首地址，其存放了管道的文件描述符 pipefd[0]、pipefd[1]。
当一个管道建立时，它会创建两个文件描述符 fd[0] 和 fd[1]。其中 fd[0] 固定用于读管道，而 fd[1] 固定用于写管道。一般文件 I / O 的函数都可以用来操作管道(lseek() 除外)。
返回值：
成功：0
失败：-1
下面我们写这个一个例子，子进程通过无名管道给父进程传递字符串数据
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define SIZE 64
int main(void)
{
int fd[2];
int i = 0;
pid_t pid = -1;
char buf[SIZE];
//创建一个无名管道 用在具有共同祖先的进程
if (pipe(fd) == -1)
{
perror("pipe");
goto err0;
}
printf("fd[0]: %d fd[1]: %d\\n", fd[0], fd[1]);
//创建子进程
pid = fork();
if (-1 == pid)
{
perror("fork");
goto err1;
}
else if (0 == pid)
{
while(1)
{
//子进程 写管道
memset(buf, 0, SIZE);
sprintf(buf, "hello uplooking %d", i++);
write(fd[1], buf, strlen(buf));
sleep(1);
if (i >= 10)
break;
}
//关闭描述符
close(fd[0]);
close(fd[1]);
exit(0);
}
else
{
//父进程 读管道
while(1)
{
memset(buf, 0, SIZE);
if (read(fd[0], buf, SIZE) <= 0)
break;
printf("\\033[31mbuf: %s\\033[0m\\n", buf);
}
//关闭描述符
close(fd[0]);
close(fd[1]);
}
return 0;
err1:
close(fd[0]);
close(fd[1]);
err0:
return 1;
}
测试结果:
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2/4sys/4th/code$ gcc 17pipe.c
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2/4sys/4th/code$ ./a.out
fd[0]: 3 fd[1]: 4
buf: hello uplooking 0
buf: hello uplooking 1
buf: hello uplooking 2
buf: hello uplooking 3
buf: hello uplooking 4
buf: hello uplooking 5
buf: hello uplooking 6
03. 管道的特性
每个管道只有一个页面作为缓冲区，该页面是按照环形缓冲区的方式来使用的。这种访问方式是典型的“生产者——消费者”模型。当“生产者”进程有大量的数据需要写时，而且每当写满一个页面就需要进行睡眠等待，等待“消费者”从管道中读走一些数据，为其腾出一些空间。相应的，如果管道中没有可读数据，“消费者” 进程就要睡眠等待，具体过程如下图所示：
默认的情况下，从管道中读写数据，最主要的特点就是阻塞问题（这一特点应该记住），当管道里没有数据，另一个进程默认用 read() 函数从管道中读数据是阻塞的。
测试代码:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
int fd_pipe[2] = {0};
pid_t pid;
if( pipe(fd_pipe) < 0 ){// 创建无名管道
perror("pipe");
}
pid = fork(); // 创建进程
if( pid < 0 ){ // 出错
perror("fork");
exit(-1);
}
if( pid == 0 ){ // 子进程
_exit(0);
}else if( pid > 0){// 父进程
wait(NULL); // 等待子进程结束，回收其资源
char str[50] = {0};
printf("before read\\n");
// 从管道里读数据，如果管道没有数据， read()会阻塞
read(fd_pipe[0], str, sizeof(str));
printf("after read\\n");
printf("str=[%s]\\n", str); // 打印数据
}
return 0;
}
测试结果:
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ gcc 1.c
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ ./a.out
before read
04. 管道设置非阻塞
当然，我们编程时可通过 fcntl() 函数设置文件的阻塞特性。
设置为阻塞：fcntl(fd, F_SETFL, 0);
设置为非阻塞：fcntl(fd, F_SETFL, O_NONBLOCK);
测试代码:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
int fd_pipe[2] = {0};
pid_t pid;
if( pipe(fd_pipe) < 0 ){// 创建无名管道
perror("pipe");
}
pid = fork(); // 创建进程
if( pid < 0 ){ // 出错
perror("fork");
exit(-1);
}
if( pid == 0 ){ // 子进程
sleep(3);
char buf[] = "hello, tom";
write(fd_pipe[1], buf, strlen(buf)); // 写数据
_exit(0);
}else if( pid > 0){// 父进程
fcntl(fd_pipe[0], F_SETFL, O_NONBLOCK); // 非阻塞
//fcntl(fd_pipe[0], F_SETFL, 0); // 阻塞
while(1){
char str[50] = {0};
read( fd_pipe[0], str, sizeof(str) );//读数据
printf("str=[%s]\\n", str);
sleep(1);
}
}
return 0;
}
测试结果:
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ gcc 1.c
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ ./a.out
str=[]
str=[]
str=[]
str=[hello, tom]
str=[]
str=[]
str=[]
str=[]
str=[]
默认的情况下，从管道中读写数据，还有如下特性：
1）调用 write() 函数向管道里写数据，当缓冲区已满时 write() 也会阻塞。
测试代码如下:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
int fd_pipe[2] = {0};
pid_t pid;
char buf[1024] = {0};
memset(buf, \'a\', sizeof(buf)); // 往管道写的内容
int i = 0;
if( pipe(fd_pipe) < 0 ){// 创建无名管道
perror("pipe");
}
pid = fork(); // 创建进程
if( pid < 0 ){ // 出错
perror("fork");
exit(-1);
}
if( pid == 0 ){ // 子进程
while(1){
write(fd_pipe[1], buf, sizeof(buf));
i++;
printf("i ======== %d\\n", i);
}
_exit(0);
}else if( pid > 0){// 父进程
wait(NULL); // 等待子进程结束，回收其资源
}
return 0;
}
测试结果:
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ gcc 1.c
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ ./a.out
i ======== 1
i ======== 2
i ======== 3
i ======== 4
i ======== 5
i ======== 6
i ======== 7
i ======== 8
i ======== 9
i ======== 10
i ======== 11
i ======== 12
i ======== 13
i ======== 14
i ======== 15
i ======== 16
i ======== 17
i ======== 18
i ======== 19
i ======== 20
i ======== 21
i ======== 22
i ======== 23
i ======== 24
i ======== 25
i ======== 26
i ======== 27
i ======== 28
i ======== 29
i ======== 30
i ======== 31
i ======== 32
i ======== 33
i ======== 34
i ======== 35
i ======== 36
i ======== 37
i ======== 38
i ======== 39
i ======== 40
i ======== 41
i ======== 42
i ======== 43
i ======== 44
i ======== 45
i ======== 46
i ======== 47
i ======== 48
i ======== 49
i ======== 50
i ======== 51
i ======== 52
i ======== 53
i ======== 54
i ======== 55
i ======== 56
i ======== 57
i ======== 58
i ======== 59
i ======== 60
i ======== 61
i ======== 62
i ======== 63
i ======== 64
到了64没有打印，说明管道的缓冲区大小是64K
2）通信过程中，别的进程先结束后，当前进程读端口关闭后，向管道内写数据时，write() 所在进程会（收到 SIGPIPE 信号）退出，收到 SIGPIPE 默认动作为中断当前进程。
测试代码:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
int fd_pipe[2] = {0};
pid_t pid;
if( pipe(fd_pipe) < 0 ){// 创建无名管道
perror("pipe");
}
pid = fork(); // 创建进程
if( pid < 0 ){ // 出错
perror("fork");
exit(-1);
}
if( pid == 0 ){ // 子进程
//close(fd_pipe[0]);
_exit(0);
}else if( pid > 0 ){// 父进程
wait(NULL); // 等待子进程结束，回收其资源
close(fd_pipe[0]); // 当前进程读端口关闭
char buf[50] = "12345";
// 当前进程读端口关闭
// write()会收到 SIGPIPE 信号，默认动作为中断当前进程
write(fd_pipe[1], buf, strlen(buf));
while(1); // 阻塞
}
return 0;
}
测试结果:
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ gcc 1.c
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$ ./a.out
deng@itcast:/mnt/hgfs/LinuxHome/code.bak2$
程序直接中断退出，没有任何结果。
05. 附录
5.1 参考博客：【Linux系统编程】进程间通信–无名管道（pipe）
以上是关于Linux系统编程—管道的主要内容，如果未能解决你的问题，请参考以下文章