【无名管道】无名管道（Pipe）与进程通信：快速上手

最新推荐文章于 2024-08-30 21:11:29 发布
最新推荐文章于 2024-08-30 21:11:29 发布
阅读量1.1k 收藏 9
点赞数 5
文章标签： linux c语言 c++ 无名管道 进程通讯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crr411422/article/details/131421001
版权

目录

0. 管道概述：

1. 管道特点

2. 管道创建：pipe函数

3. 管道的读写特点

4. 通过fcntl函数设置文件的阻塞特性

5. 查看管道缓冲区命令

总结：

0. 管道概述：

        管道也叫无名管道，它是是 UNIX 系统 IPC（进程间通信） 的最古老形式，所有的 UNIX 系统都支持这种通信机制。

        无名管道是创建在内核空间的，多个进程知道同一个无名管道的空间，就可以利用它来进行通信。（在32位操作系统下，任何一个进程创建时，系统都会给其分配4G的虚拟内存，3G为用户空间，1G为内核空间）

        无名管道虽然是在内核空间创建的，但是会给当前用户进程两个文件描述符，一个负责执行读操作，一个负责写操作。

1. 管道特点

1) 半双工，数据在同一时刻只能在一个方向上流动。

2) 数据只能从管道的一端写入，从另一端读出。

3) 写入管道中的数据遵循先入先出的规则。

4) 管道所传送的数据是无格式的，这要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。

5) 管道不是普通的文件，不属于某个文件系统，其只存在于内存中。

6) 管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。

7) 从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据。

8) 管道没有名字，只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。

        对于管道特点的理解，我们可以类比现实生活中管子，管子的一端塞东西，管子的另一端取东西。管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。

2. 管道创建：pipe函数

pipe函数：

#include <unistd.h>
int pipe(int pipefd[2]);
功能：创建无名管道，返回两个文件描述符负责对管道进行读写操作
参数：
    pipefd : 为 int 型数组的首地址，其存放了管道的文件描述符 pipefd[0]、pipefd[1]。

                 pipefd[0]:负责对管道执行读操作。

                 pipefd[1]:负责对管道执行写操作。
                 一般文件 I/O的函数都可以用来操作管道(lseek() 除外)。
返回值：
    成功：0
    失败：-1

 代码示例：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>

int main()
{
    int fd_pipe[2];
    if (pipe(fd_pipe) == -1) {
        perror("fail to pipe");
        exit(1);
    }

    printf("fd_pipe[0] = %d\n", fd_pipe[0]);
    printf("fd_pipe[1] = %d\n", fd_pipe[1]);

    if (write(fd_pipe[1], "hello world ", 12) == -1) {
        perror("fail to write");
        exit(1);
    }
    write(fd_pipe[1], "nihao beijing", strlen("nihao biejing") + 1);
    char buf[32] = "";
    ssize_t bytes;
    if ((bytes = read(fd_pipe[0], buf, sizeof(buf))) == -1) {
        perror("fail to read");
        exit(1);
    }
    printf("buf = %s\n", buf);
    printf("bytes = %ld\n", bytes);
    return 0;
}

 父子进程通过管道实现数据的传输

 示例代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>

int main()
{
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    int pipeff[2];
    if (pipe(pipeff) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }

    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        char buf[128] = "";
        char buu[128] = "";
        while (1)
        {
            fgets(buf, sizeof(buf), stdin);
            buf[strlen(buf) - 1] = '\0';

            if (write(pipefd[1], buf, sizeof(buf)) == -1)
            {
                perror("fail to write");
                exit(1);
            }

            if (read(pipeff[0], buu, sizeof(buu)) == -1)
            {

                perror("fail to read ");
                exit(1);
            }
            printf("buu = %s\n", buu);
        }

    }
    else
    {
        char buf[128] = "";
        char buu[128] = "";
        while (1)
        {
            if (read(pipefd[0], buf, sizeof(buf)) == -1)
            {

                perror("fail to read ");
                exit(1);
            }
            printf("buf = %s\n", buf);


            fgets(buu, sizeof(buu), stdin);
            buu[strlen(buu) - 1] = '\0';

            if (write(pipeff[1], buu, sizeof(buu)) == -1)
            {
                perror("fail to write");
                exit(1);
            }
        }

    }
    return 0;
}

3. 管道的读写特点

使用管道需要注意以下4种特殊情况（假设都是阻塞I/O操作，没有设置O_NONBLOCK标志）：

1. 读写端都存在，只读不写：

    //读写端都存在，只读不写
    //如果管道中有数据，会正常读取数据
    //如果管道中没有数据，则读操作会阻塞等待，直到有数据为止

2. 读写端都存在，只写不读

    //读写端都存在，只写不读
    //如果一直执行写操作，则无名管道对应的缓冲区会被写满，写满之后，write函数也会阻塞等待
    //默认无名管道的缓冲区64K字节

3. 只有读端

    //关闭文件描述符，只有读端
    //如果管道中有数据，则读操作正常读取数据
    //如果管道中没有数据，则read函数返回0

4. 只有写段

    //关闭读端，只有写端
    //关闭读端，一旦执行写操作，立刻产生一个SIGPIPE（管道破裂）
    //这个信号默认处理方式是退出进程

读写端都存在，只读不写

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>

int main()
{
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    //读写端都存在，只读不写
    //如果管道中有数据，会正常读取数据
    //如果管道中没有数据，则读操作会阻塞等待，直到有数据为止
    write(pipefd[1], "hello world", 11);
    char buf[128] = "";
    if (read(pipefd[0], buf, sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("buf = %s\n", buf);

    if (read(pipefd[0], buf, sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("buf = %s\n", buf);
    return 0;
}
~

读写端都存在，只写不读

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>

int main()
{
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    //读写端都存在，只写不读
    //如果一直执行写操作，则无名管道对应的缓冲区会被写满，写满之后，write函数也会阻塞等待
    //默认无名管道的缓冲区64K字节
    int num = 0;
    while (1)
    {
        if (write(pipefd[1], "666", 1024) == -1)
        {
            perror("fail to write");
            exit(1);
        }
        num++;
        printf("num = %d\n", num);
    }
    return 0;
}

只有读端

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>


int main()
{
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    write(pipefd[1], "hello world", 11);
    //关闭文件描述符，只有读端
    //如果管道中有数据，则读操作正常读取数据
    //如果管道中没有数据，则read函数返回0
    close(pipefd[1]);

    char buf[128] = "";
    ssize_t bytes;
    if ((bytes = read(pipefd[0], buf, sizeof(buf))) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("bytes = %ld\n", bytes);
    printf("buf = %s\n", buf);

    memset(buf, 0, sizeof(buf));
    if ((bytes = read(pipefd[0], buf, sizeof(buf))) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("bytes = %ld\n", bytes);
    printf("buf = %s\n", buf);
    return 0;
}

只有写

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>

void handler(int sig) {
    printf("SIGPIPE发生了，管道破裂\n");
}
int main()
{
    signal(SIGPIPE, handler);
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    //关闭读端，只有写端
    //关闭读端，一旦执行写操作，立刻产生一个SIGPIPE（管道破裂）
    //这个信号默认处理方式是退出进程
    close(pipefd[0]);

    int num = 0;
    while (1)
    {
        if (write(pipefd[1], "hello", 1024) == -1)
        {
            perror("fail to write");
            exit(1);
        }
        num++;
        printf("num = %d\n", num);
    }
    return 0;
}

4. 通过fcntl函数设置文件的阻塞特性

设置为阻塞：

        fcntl(fd,F_SETFL,0);

设置为非阻塞：

        fcntl(fd,F_SETFL,O_NONBLOCK);

非阻塞：如果是阻塞，管道中没有数据，read会一直等待，直到有数据才会继续运行，否则一直等待。

设置方法：

//获取原来的flags
int flags = fcntl(fd[0], F_GETFL);
// 设置新的flags
flag |= O_NONBLOCK;
// flags = flags | O_NONBLOCK;
fcntl(fd[0], F_SETFL, flags);

结论： 如果写端没有关闭，读端设置为非阻塞， 如果没有数据，直接返回-1。

        如果是非阻塞，read函数运行时，会先看一下管道中是否有数据，如果有数据，则正常运行读取数据，如果管道中没有数据，则read函数会立即返回，继续下面代码运行。

include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>

int main()
{
    int fd_pipe[2];
    char buf[] = "hello world";
    pid_t pid;

    if (pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }

    pid = fork();
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        fcntl(fd_pipe[0], F_SETFL, O_NONBLOCK);
        while (1)
        {
            memset(buf, 0, sizeof(buf));
            read(fd_pipe[0], buf, sizeof(buf));
            printf("buf = %s\n", buf);
            sleep(1);
        }
    }
    else
    {
        while (1)
        {
            sleep(5);
            write(fd_pipe[1], buf, strlen(buf));
        }
    }
    return 0;
}

5. 查看管道缓冲区命令

可以使用ulimit -a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。

 查看管道缓冲区函数

#include <unistd.h>
​
long fpathconf(int fd, int name);
功能：该函数可以通过name参数查看不同的属性值
参数：
    fd：文件描述符
    name：
        _PC_PIPE_BUF，查看管道缓冲区大小
        _PC_NAME_MAX，文件名字字节数的上限
返回值：
    成功：根据name返回的值的意义也不同。
    失败： -1

示例：

int main()
{
    int fd[2];
    int ret = pipe(fd);
    if (ret == -1)
    {
        perror("pipe error");
        exit(1);
    }
​
    long num = fpathconf(fd[0], _PC_PIPE_BUF);
    printf("num = %ld\n", num);
​
    return 0;
}

总结：

        无名管道是一种强大且基础的进程间通信机制，它使得具有亲缘关系的进程之间能够方便地共享数据。无名管道的使用，无论是在简单的Shell命令，还是在复杂的多进程应用中，都有着广泛的应用。

        注意：无名管道只能在具有公共祖先的进程之间使用，且只能实现单向通信。

SecureCode
关注
2024年联发科嵌入式面试题及参考答案
大模型大数据攻城狮的专栏
10-09 1088
例如，在一个图形绘制项目中，可以将图形的绘制算法和数据封装在一个图形类中，外部代码只需要调用图形类的绘制接口即可，而不需要了解具体的绘制算法和数据结构。例如，在一个图形绘制项目中，可以定义一个抽象基类 “图形”，然后派生出不同类型的图形类，如 “圆形”、“矩形”、“三角形” 等。例如，在一个游戏开发项目中，可以创建一个基类 “角色”，然后派生出不同类型的角色类，如 “玩家角色”、“敌人角色” 等，这些派生类可以继承基类的属性和方法，如移动、攻击等，同时可以根据需要添加自己特有的属性和方法。
无名管道（pipe）通信
qq_38211852的博客
05-26 401
这个程序用无名管道实现命令 cat /etc/passwd  |  grep root其实在终端命令中 | 就是一个管道 cat /etc/passwd会把结果打印到标准输出 ，grep  root 会把结果从标准输入实现流程：1.父进程生产两个子进程(进程扇的概念)2.子进程A:     a: 把标准输出定位到管道写端，因为此时cat /etc/passwd的结果原本要输出到标准输出，这里我们必...
Linux系统开发 | 进程通信之无名管道
本末实验室
08-02 1099
概述拥有梦想是一种智力，实现梦想是一种能力概述若是一个多线程的进程，由于各个线程共享一个地址空间，可以直接通过变量的形式进行通信。而进程，由于各个进程独占一个地址空间，我们需要一种通信机制来完成进程间的数据交互。之间有区分与各自的运用场景，其中套接字通常使用在网络服务，其他只能在本地场景下使用。笔者以后会逐一学习，本章介绍无名管道。
进程间通信----管道篇
最新发布
新手嵌入式学习的博客
08-30 1437
无名管道，有名管道
管道-无名管道
dongyanxia1000的专栏
02-12 663
管道（pipe）概述：（怎样使用管道实现父子进程间通信）不相关的两个进程无法通过无名管道进行进程间通信。管道又称无名管道（没有名字），无名管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。管道是最古老的UNIX IPC方式，其特点是：1&gt; 半双工，数据在同一时刻只能在一个方向上流动。（单工-收音机）2&gt; 数据只能从管道的一端写入，从另一端读出。3&gt; 写入管...
无名管道通信
Mylily_123的博客
10-19 525
在上一篇《有名管道通信》中，介绍了有名管道通信，相对于有名管道通信而言，今天说一下无名管道通信。 有名管道通信在文件目录树中有标示，而无名管道通信是没有标示的。相对于有名管道而言，无名管道在使用时产生，使用后释放，并不会在系统上留下任何痕迹。正是由于这一特点，无名管道通信是有限制的，只能应用于父子进程之间。因为子进程是复制父进程的文件表数组（浅拷贝）。 无名管道操作： 1、创
无名管道的通信
Fitz的博客
03-25 952
通过使用管道实现两个或多个进程之间的通信。所谓管道，就是将一个进程的标准输出与另一个进程的标准输入联系在一起，进行通信的一种方法。同组进程之间可用无名管道任意通信，而不同组进程之间可通古共有名管道进行通信。 使用无名管道pipe(）,进行父子进程之间的通信。 #include #include #include #include #include int pipe(int
【进程间通信优化】：使用Select提升通信效率的技巧
进程间通信（Inter-Process Communication, IPC）是操作系统中不同进程之间相互交换信息、数据或信号的一组技术。它对于协调多任务执行、资源共享、任务分配和数据同步等方面至关重要。 ## 1.2 进
结构体数据共享：进程间通信的5种高效方法
在操作系统中，进程间通信（IPC）是不同进程之间交换数据或信号的一个过程，这一过程对现代软件开发至关重要。不同的进程可以在同一台机器上或者跨越网络进行通信。进程间通信能够实现数据共享、任务协调、资源访问...
Beginning Linux Programming(4rdEn).pdf
12-03
读者将学会如何使用无名管道和命名管道来进行进程间通信。 ##### 第14章：信号量、共享内存和消息队列 (Semaphores, Shared Memory, and Message Queues) 本章进一步扩展了进程间通信的内容，介绍了更复杂的IPC...
Linux：进程间通信（创建匿名管道，父子进程间通信，兄弟进程间通信）
Gabriel.Tian的博客
05-09 3371
过一遍管道的基础知识： 1.本质：存在于高速缓存区，属于伪文件，不占用磁盘空间。缓冲区大小默认4K，可根据实际情况适当调整 2.读端和写端各自对应一个文件描述符，数据从写端流入，读端流出 3.操作管道的进程被销毁之后，管道占用的内存空间自动被释放 4.管道默认阻塞 5.内部实现方式：循环队列 （先进先出），属于半双工。数据只能读一次，不能重复读取 6.匿名管道创建：int pipe(int pip...
无名管道
pejay23的博客
12-21 97
```cpp #include "unistd.h" #include "stdio.h" #include "stdlib.h" int main() { int ret; int fd[2]; char buf[]="hello linux\n"; char readbuf[128]={0}; ret=pipe(fd); if(ret<0) { printf("create pipe failure."); .
无名管道通信，有名管道通信
m0_46186017的博客
04-28 196
//无名管道通信 仅适用于父进程和子进程之间的传送 #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> int main() { int fd[2] = {0}//fd[0]读，fd...
一、无名管道
weixin_57886538的博客
01-17 720
无名管道概述 管道(pipe)又称无名管道。无名管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。任何一个进程在创建的时候，系统都会给他分配4G的虚拟内存，分为3G的用户空间和1G的内核空间，内核空间是所有进程公有的，无名管道就是创建在内核空间的，多个进程知道同一个无名管道的空间，就可以利用他来进行通信
无名管道（一）
dai__liang的博客
11-21 218
管道 UNIX网络编程：进程间的通信 手写之管道篇 代码 myhead.h #ifndef MYHEAD_H_ #define MYHEAD_H_ #include<stdio.h> #include<sys/types.h> #include<sys/wait.h> #include<unistd.h> #include<stdlib.h> #include<errno.h> #include<string.h> #in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SecureCode

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值