Linux系统编程- 无名管道(匿名管道)

最新推荐文章于 2022-05-06 10:00:20 发布
最新推荐文章于 2022-05-06 10:00:20 发布
阅读量589 收藏 2
点赞数 1
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010386121/article/details/116485350
版权

无名管道作为Linux进程间通讯，我们这里把理论和实际结合起来说明。

1.什么是管道

管道，英文位pipe,在学习linux系统编程一个重要概念.它的发明人是道格拉斯.麦克罗伊，这位也是UNIX上早期shell的发明人。他在发明了shell之后，发现系统操作执行命令的时候，经常有需求要将一个程序的输出交给另一个程序进行处理，这种操作可以使用输入输出重定向加文件搞定，比如：

输入以下命令行：

yates@yates-virtual-machine:~/test/code/FOLDER$ ls  -l /etc/ > etc.txt
yates@yates-virtual-machine:~/test/code/FOLDER$ wc -l etc.txt 
255 etc.txt

后面发明管道，在shell中，可以使用 “|”连接个命令，shell会把前后两个命令输入输出用一个管道相连，以便得到进程间通讯的目的。

yates@yates-virtual-machine:~/test/code/FOLDER$ ls  -l /etc/ | wc -l
255

以上两种方法，你认为分开两个进程，前面进程以写入方式打开文件，后面以读的方式打开。管道内容缓存在内存中。

无名管道：

它的特点只能在父子进程中使用，父进程产生子进程前打开一个管道文件，然后fork后，子进程拷贝父进程的管道文件描述符，以达到共用一个管道通信的目的。除了父子进程外，别的都不知道该管道文件符，确保数据传输安全性。

 

创建匿名管道：

匿名管道创建非常简单，用pipe函数创建出两个文件描述符，再用write，read分别对管道进行读写数据。请看以下demo

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#define BUFSIZE 4096
#define STRING "1231313"

int main(void)
{
    int fd[2];
    char buf[BUFSIZ];
    if (pipe(fd) == -1)
    {
        perror("pipe error");
        exit(1);
    }
    int ret;
    int count = 0;

    ret = write(fd[1], STRING, strlen(STRING));
    if (ret < 0)
    {
        perror("write error ");
        exit(1);
    }
    ret = read(fd[0],buf,sizeof(buf));
    if(ret < 0){
        perror("read error");
        exit(1);
    }
    printf("read buffer =%s\r\n",buf);
    exit(0);
}

以上代码执行结果是

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
read buffer =1231313

以上demo列举最简单匿名管道创建和读写操作。

 

注意：fd[1]用来写操作，fd[0]用来读操作。

如果在两个进程之间，应该怎么通过管道进行通讯呢？

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"
int main()
{
    int pipefd[2];
    pid_t pid;
    char buf[BUFSIZ];
    if (pipe(pipefd) == -1)
    {
        perror("pipe error\r\n");
        exit(1);
    }
    int ret = 0;
    pid = fork();
    if (pid == -1)
    {
        perror("fork error \r\n");
        exit(1);
    }
    else if (pid == 0)
    {
        printf("this is a child,pid=%d\r\n", getpid());
        write(pipefd[1], STRING, strlen(STRING));
    }
    else
    {
        printf("this is a father , pid=%d\r\n", getpid());
        ret = read(pipefd[0], buf, sizeof(STRING));
        if(ret<0){
            printf("read data error %d\r\n",ret);
            exit(1);
        }
        printf("%s\r\n", buf);
    }
    exit(0);
}

以上demo运行结果是：

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
this is a father , pid=10043
this is a child,pid=10044
1231313

 

阻塞和非阻塞

管道可以分为阻塞和非阻塞，通过fcntl函数设置

当没有数据可读时

  • O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
  • O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

当管道满的时候

  • O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
  • O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

当默认创建文件描述符时，默认是打开阻塞模式，请看一下demo。

情况一：默认打开阻塞模式，只有读操作

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"

int main(void)
{
    int fd[2];
    char buf[BUFSIZ];
    if (pipe(fd) == -1)
    {
        perror("pipe error");
        exit(1);
    }
    int ret;
    int count = 0;
    printf("ready to read pipe data\r\n");
    ret = read(fd[0],buf,sizeof(buf));
    if (ret < 0)
    {
        perror("read error ");
        exit(1);
    }
    printf("buffer:%s\r\n",buf);
}

运行以上demo结果是：

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
ready to read pipe data

程序一直阻塞在read函数，因为此时read函数默认为阻塞模式。

情况二：非阻塞read

通过设置fcntl函数设置read模式为非阻塞模式。

 int flag = fcntl(fd[0],F_GETFL); //读取默认模式
 ret = fcntl(fd[0],F_SETFL,flag | O_NONBLOCK);//使能非阻塞模式

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"
int main(void)
{
    int fd[2];
    char buf[BUFSIZ];
    if (pipe(fd) == -1)
    {
        perror("pipe error");
        exit(1);
    }
    
    
    int ret;
    int count = 0;
    int flag = fcntl(fd[0],F_GETFL);//读取默认配置
    ret = fcntl(fd[0],F_SETFL,flag | O_NONBLOCK);//使能非阻塞模式
    printf("ready to read pipe data\r\n");
    ret = read(fd[0],buf,sizeof(buf));
    if (ret < 0)
    {
        printf("read error :%d\r\n",ret);
        exit(1);
    }
    printf("buffer:%s\r\n",buf);
}

执行以上程序结果是：

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
ready to read pipe data
read error :-1

结论：当没有write函数情况下，raad函数立即返回为-1.

 

情景三：如果先关闭写文件描述符，在非阻塞模式下只读取数据

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"
int main(void)
{
    int fd[2];
    char buf[BUFSIZ];
    if (pipe(fd) == -1)
    {
        perror("pipe error");
        exit(1);
    }
    
    
    int ret;
    int count = 0;
    int flag = fcntl(fd[0],F_GETFL);
    ret = fcntl(fd[0],F_SETFL,flag | O_NONBLOCK);
    printf("ready to read pipe data\r\n");
    close(fd[1]);
    ret = read(fd[0],buf,sizeof(buf));
    if (ret < 0)
    {
        printf("read error :%d\r\n",ret);
        exit(1);
    }
    printf("ret=%d,buffer:%s\r\n",ret,buf);
}

执行以上demo结果是

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
ready to read pipe data
ret=0,buffer:

当关闭写文件描述符时，read函数立马返回0.

会有小伙伴问，如果关闭读文件描述符fd[0]能，这里不上代码，read函数结果返回-1.

结论：在非阻塞模式下，当关闭写文件描述符时，read函数立马返回0。如果关闭读文件描述符fd[0]能，read结果返回-1。

 

情景四：如果在阻塞模式下，只写入数据。

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"
int main(void)
{
    int fd[2];
    if (pipe(fd) == -1)
    {
        perror("pipe error");
        exit(1);
    }
    int ret;
    int count = 0;

    ret = write(fd[1], STRING, strlen(STRING));
    if (ret < 0)
    {
        perror("write error ");
        exit(1);
    }
    printf("end\r\n");
}

运行结果是：

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
end

说明第一次写入write成功，但是如果循环写入呢？

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
write count=0
write count=1
write count=2
write count=3
write count=4
write count=5
write count=6
write count=7
write count=8
write count=9
write count=10
...
write count=9352
write count=9353
write count=9354
write count=9355
write count=9356
write count=9357
write count=9358
write count=9359

结果去到9359次停止，为什么呢？

这里需要说到管道容量。

管道实际上就是内核控制的一个内存缓冲区，有容量上线，我们这里把最大缓冲大小命名为PIPESIZE，注意，PIPESIZE最小为一页，如果电脑磁盘格式为4k的话，那PIPESIZE最小为4096，但是在64位ubuntu系统上，通过查看/proc/sys/fs/pipe-max-size ，PIPESIZE设置为1048576（2^20）。

管道容量大小可以设置的，通过fcntl 设置F_SETPIPE_SZ设置容量大小，注意最低为1page（一般系统为4096）。

int ret = fcntl(fd[1],F_SETPIPE_SZ,BUFSIZE);//该函数设置管道大小。

请看以下demo

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"
int main(void){
    int fd[2];
    if(pipe(fd)==-1){
        perror("pipe error");
        exit(1);
    }
    int ret ;
    int count =0;
    ret = fcntl(fd[1],F_SETPIPE_SZ,BUFSIZE);
    while(1){
        ret = write(fd[1],STRING,strlen(STRING));
        if(ret < 0 ){
            perror("write error ");
            exit(1);
        }
        
        printf("write count=%d\r\n",count);
        count ++;
    }
}

以上demo执行结果为

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
write count=0
write count=1
write count=2
write count=3
write count=4
write count=5
write count=6
write count=7
write count=8
write count=9
write count=10
write count=11
write count=12
write count=13
write count=14
write count=15
write count=16
write count=17
write count=18
write count=19
write count=20
write count=21
write count=22
write count=23
write count=24
write count=25
...
write count=567
write count=568
write count=569
write count=570
write count=571
write count=572
write count=573
write count=574
write count=575
write count=576
write count=577
write count=578
write count=579
write count=580
write count=581
write count=582
write count=583
write count=584

比上个demo代码write执行次数少了很多。

结论：在阻塞模式下，当管道容量未达到上上限时，write函数可以成功写进入，当达到容量上限是，write函数会一直阻塞。

 

场景五：在非阻塞模式下一直写入

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <fcntl.h>
#define BUFSIZE 4096
#define STRING "1231313"
int main(void){
    int fd[2];
    if(pipe(fd)==-1){
        perror("pipe error");
        exit(1);
    }
    int ret ;
    int count =0;
    int flag = fcntl(fd[1],F_GETFL);
    fcntl(fd[1],F_SETFL,flag|O_NONBLOCK);
    ret = fcntl(fd[1],F_SETPIPE_SZ,BUFSIZE);
    while(1){
        ret = write(fd[1],STRING,strlen(STRING));
        if(ret < 0 ){
            perror("write error ");
            exit(1);
        }
        
        printf("write count=%d\r\n",count);
        count ++;
    }
}

运行结果为

yates@yates-virtual-machine:~/test/code/FOLDER$ ./pipe 
write count=0
write count=1
write count=2
write count=3
write count=4
write count=5
write count=6
write count=7
write count=8
write count=9
write count=10

...
write count=560
write count=561
write count=562
write count=563
write count=564
write count=565
write count=566
write count=567
write count=568
write count=569
write count=570
write count=571
write count=572
write count=573
write count=574
write count=575
write count=576
write count=577
write count=578
write count=579
write count=580
write count=581
write count=582
write count=583
write count=584
write error : Resource temporarily unavailable

结论，当PIPESIZE满的时候，write函数返回为-1.

按照以上场景，总结出以下结论：

O_NONBLOCK关闭，n <= PIPESIZE：

n个字节的写入操作是原子操作，write系统调用可能会因为管道容量(PIPESIZE)没有足够的空间存放n字节长度而阻塞。

O_NONBLOCK打开，n <= PIPESIZE：

如果有足够的空间存放n字节长度，write调用会立即返回成功，并且对数据进行写操作。空间不够则立即报错返回，并且errno被设置为EAGAIN。

O_NONBLOCK关闭，n > PIPESIZE：

对n字节的写入操作不保证是原子的，就是说这次写入操作的数据可能会跟其他进程写这个管道的数据进行交叉。当管道容量长度低于要写的数据长度的时候write操作会被阻塞。

O_NONBLOCK打开，n > PIPESIZE：

如果管道空间已满。write调用报错返回并且errno被设置为EAGAIN。如果没满，则可能会写入从1到n个字节长度，这取决于当前管道的剩余空间长度，并且这些数据可能跟别的进程的数据有交叉。

风摇烨
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux编程练习：无名管道练习
HKH368的博客
03-06 551
1 /在程序中调用fork创建子进程，然后在父进程中读取argc[1]所指向的 2 /文本文件，将文件内容通过管道传送给子进程，再由子进程将收到的文 3 /件内容的各行按字典序排序后输出到屏幕 4 include<stdio.h> 5 include<sys/types.h> 6 include<sys/stat.h> 7 include<fcntl.h> 8 include<unistd.h> 9 inclu...
Linux进程间通信之有名无名管道
Danny_llp的博客
07-25 242
Linux进程间通信之有名无名管道 一：无名管道 通信原理： 管道文件是一个特殊的文件，是由队列来实现的。 在文件IO中创建一个文件或打开一个文件是由open函数来实现的，它不能创建管道文件。只能用pipe函数来创建管道。（open函数只能创建普通文件） 函数形式：int pipe(int fd[2]) 功能：创建管道，为系统调用：unistd.h 参数：就是得到的文件描述符。可见有两个文件描述符：fd[0]和fd[1]，管道有一个读端fd[0]用来读和一个写端fd[1]用来写，这个规定不能变。（有了文件
Linux无名管道编程
小水晶的专栏
03-05 1178
 无名管道只能用于父子进程间通信，pipe函数用一个数组作参数，数组fd中fd[0]用于读，fd[1]用于写。代码如下：#include#include#include#include#includeint main(){  int pipe1_fd[2], pipe2_fd[2];      char * parent_talks[] = {"Hi, my baby","Can yo
【Linux系统编程学习】匿名管道pipe与有名管道fifo
fjtooo的博客
10-26 275
此为牛客Linux C++和黑马Linux系统编程课程笔记。 0. 关于进程通信 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。 在进程间完成数据传递需要借助操作系统提供特殊的方法，如：文件
linux c无名管道,Linux C 编程----无名管道PIPE
weixin_33618482的博客
05-15 285
无名管道PIPE特点：1.它只能用于具有亲缘关系的进程之间的通信(也就是父子进程或者兄弟进程之间)2.它是一个半双工的通信模式，具有固定的读端和写端。3.管道也可以看成是一种特殊的文件，对于它的读/写也可以使用普通的 read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。无名管道函数原型：#includeintpipe(intfiledes[2])...
Linux系统教学中关于命名管道文件的解析.pdf
09-06
- 无名管道是匿名的，不存在于文件系统中，而命名管道通过文件路径可被其他进程找到并使用。 3. **使用命名管道** - **命令方式**：可以使用重定向操作符`和`>`，将命令的输出或输入与命名管道关联，例如`echo ...
《Linux高级系统编程》教学教案—05早期进程间通信.pdf
06-22
首先，无名管道是最基础的IPC形式之一，它源于UNIX系统，并被Linux广泛采用。无名管道的核心在于它是一种半双工通信方式，即数据只能单向流动。管道实质上是内核中的一块缓冲区，位于内核空间，由创建它的进程共享。...
linux进程间通信管道
01-14
命名管道与匿名管道的主要区别在于，匿名管道是无名的，只能在有亲缘关系的进程之间使用，而命名管道可以在没有亲缘关系的进程之间进行通信，通过一个文件系统路径进行标识。命名管道在Linux中被实现为一种特殊的...
LINUX管道通信实验报告
05-24
2. 无名管道：管道是匿名的，没有名字，只能由创建它的进程直接使用。 3. 数据同步：管道中的数据是按先进先出（FIFO）原则处理的，但读写进程之间的同步需由用户自己控制，避免读写冲突。 4. 缓冲区大小限制：管道...
深入浅出Linux环境编程（进程基础+IPC+POSIX+线程同步与互斥）配套资料
05-06
- IPC机制允许不同进程间交换数据，常见的有管道（命名管道和无名管道）、消息队列、共享内存、信号量和套接字等。 - 图解异步信号与其生命周期：信号是一种异步通信方式，用于通知进程发生了特定事件，如`SIGINT`...
【实验三】Linux的匿名管道的编程
一指流沙的博客
05-06 282
一、匿名管道具体介绍 (3条消息) Linux系统编程（11）——进程间通信-概念、匿名管道pipe、命名管道mkfifo_Mood Crows的博客-CSDN博客https://blog.csdn.net/qq_42659468/article/details/90414265?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165179642816780366593991%2522%252C%2522scm%2522%253A%25222
Linux 进程间通讯之创建无名管道和读写无名管道
Knowledge Archiving and Sharing
12-21 5378
Linux进程间通讯的方式： 1.     管道(pipe)和有名管道(FIFO). 2.     信号(signal) 3.     消息队列 4.     共享内存 5.     信号量 6.     套接字(socket)     管道通讯： 无名管道：由pipe()函数创建，int pipe(int  filedis[2]), 当管道建立时有两个文件描述符，file
linux之无名管道pipe
爱奇途
09-24 1014
#include #include #include #include #include #include int main() {         int pipe_fd[2]; //创建管道标识符         pid_t pid;
Linux系统编程—进程间通信—无名管道
L132455的博客
04-17 254
无名管道 无名管道和有名管道是Linux系统内核的特殊文件，用于进程之间的通信。 无名管道相当于一个队列结构，fd[1]为写入端（入队），fd[0]为读出端（出队）。其中信息读出后即删除，再次读取时即为下一个信息。 头文件 #include <unistd.h> 函数原型 int pipe(int pipefd[2]); 功能：创建无名管道文件。无名管道是一个特殊文件，不可由open函数创建。 参数：fd[2]有两个成员 fd[0]和 fd[1]，他们都是文件描述
Linux系统进程间通信：匿名管道pipe
记录和分享程序人生的点点滴滴
06-12 2094
管道是最早的进程间通信方式之一，早在UNIX系统中就存在了，几乎所有的UNIX系统都支持这种方式。
Linux--无名管道pipe示例
活到老，学到老
07-24 552
无名管道pipe用于父子进程之间的通信。 e
linux中有名管道与匿名管道的实现
weixin_46199479的博客
03-28 721
一、匿名管道 多用于父进程与子进程之间的通信，用到的频率很高，挺重要的。定义一个大小为2的数组、使用pipe函数将其变为匿名管道的两端，fd[0]：代表读端、fd[1]：代表写端。子进程和父进程根据功能分别关闭读或写端。当然是使用read和write函数来对管道的数据进行读写，下面这个函数的功能就是父进程给子进程传输hello world，子进程读后把字符串发送到标准输出上。如下图可以看到结果是正确的。使用完都关掉、养成好习惯。 int pipe(int filedes[2]); ..
创建无名管道
weixin_46571142的博客
09-22 133
#include <stdio.h> #include <unistd.h> #include <string.h> int main() { int fd[2]; //int pipe(int pipefd[2]); pid_t pid; char buff[128]; if(pipe(fd)<0) printf(“creat pipe error\n”); if((pid = fork())<0) printf(“creat child failed\n”
linux系统调用创建无名管道,【Linux系统编程】进程间通信--无名管道（pipe）
weixin_31125161的博客
05-14 578
管道的概述管道也叫无名管道，它是是 UNIX 系统 IPC(进程间通信) 的最古老形式，所有的 UNIX 系统都支持这种通信机制。无名管道有如下特点：1、半双工，数据在同一时刻只能在一个方向上流动。2、数据只能从管道的一端写入，从另一端读出。3、写入管道中的数据遵循先入先出的规则。4、管道所传送的数据是无格式的，这要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。5、管道不...
linux管道符是无名管道
最新发布
06-10
是的，Linux管道符是一种无名管道（Anonymous Pipe），也被称为匿名管道。 无名管道是一种用于进程间通信的机制，它可以在父进程和子进程之间建立一个通道，使得它们可以通过这个通道进行数据的传输。无名管道是一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值