pipe和pipefd

🕗 发布于 2024-10-10 16:20 linux 管道 pipe

Linux 中 pipe 的详细介绍

在 Linux 中，pipe 是一个系统调用，用于创建一个管道，这是一种用于进程间通信（IPC）的机制。管道允许两个进程之间进行单向数据传输，通常是一个进程向管道写入数据，而另一个进程从管道读取数据。

管道的工作原理

当 pipe 调用成功时，它会返回两个文件描述符，分别对应管道的两端：pipefd[0] 和 pipefd[1]。

pipefd[0] 通常用于读取数据。
pipefd[1] 通常用于写入数据。

数据从 pipefd[1] 写入后，会存储在内核缓冲区中，直到被 pipefd[0] 的读取操作读取。

创建管道

使用 pipe 系统调用来创建管道：

#include <unistd.h>

int pipe(int pipefd[2]);

如果 pipe 调用成功，它将返回 0；如果失败，则返回 -1，并且 errno 将被设置以指示错误。

管道的用法

以下是一个简单的例子，展示了如何使用 pipe：

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    int pipefd[2];
    pid_t cpid;

    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    // 创建子进程
    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        close(pipefd[0]);
        close(pipefd[1]);
        return 1;
    }

    if (cpid == 0) { // 子进程
        // 关闭不需要的文件描述符
        close(pipefd[1]);
        // 读取管道中的数据
        char message[20];
        read(pipefd[0], message, sizeof(message) - 1);
        printf("Received: %s\n", message);
        close(pipefd[0]);
        return 0;
    } else { // 父进程
        // 关闭不需要的文件描述符
        close(pipefd[0]);
        // 写入数据到管道
        const char *message = "Hello, this is the parent!";
        write(pipefd[1], message, strlen(message));
        close(pipefd[1]);
        // 等待子进程结束
        wait(NULL);
        return 0;
    }
}

pipefd 的介绍

pipefd 是一个整数数组，它包含两个元素，用于存储管道的两个文件描述符。在创建管道后，pipefd[0] 和 pipefd[1] 分别被赋予管道的读取和写入端。

pipefd[0]：管道的读取端，通常用于从管道中读取数据。
pipefd[1]：管道的写入端，通常用于向管道中写入数据。

在上述例子中，pipefd 被用作参数传递给 pipe 函数，并在子进程中用于读取数据，在父进程中用于写入数据。

注意事项

当一个进程关闭管道的任一端时，另一个进程会收到一个 SIGPIPE 信号，除非它已经设置了 SIG_IGN 或 SIG_ERR 处理程序。
管道是单向的，如果你需要双向通信，需要创建两个管道。
管道是阻塞的，这意味着如果管道的另一端没有准备好读取或写入，操作会阻塞直到条件满足。

总结

pipe 是 Linux 中实现进程间通信的一种简单而有效的方法。通过 pipefd，可以访问管道的两个端点，从而实现数据的双向传输。正确使用 pipe 和 pipefd 可以帮助开发者实现高效的进程间通信。

自己总结

pipe创建一个管道

pipe的介绍

1完成这件事：

看图分析

运行结果

#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{
    //创建管道
    //先创建一个pipefd数组
    int pipefd[2];
    //用n接受一下，判断是否成功
    int n = pipe(pipefd);
    if(n<0) return 1;//创建失败了

    //创建成功
    //测试一下文件描述符是3和4
    cout<<"pipefd[0]:"<<pipefd[0]<<"pipefd[1]:"<<pipefd[1]<<endl;
    

    return 0;
}

2完成这件事：

创建一个子进程

 pid_t id = fork();
    if(id < 0)return 2;//创建失败
    if(id == 0)//创建成功
    {
        //子进程

    }
    //父进程

让子进程写入，父进程读取

要想让子进程进程写，就需要在进程中关闭读端

if(id == 0)//创建成功
{
     //子进程
     close(pipefd[0]);
}

同理

//父进程
close(pipefd[1]);

都用完结束后，可以都关掉

    if(id == 0)//创建成功
    {
        //子进程
        close(pipefd[0]);
        //.....
        close(pipefd[1]);
    }
    //父进程
    close(pipefd[1]);
    //.....
    close(pipefd[0]);

IPC code，写通信代码

3这件事也完成了：

结构就有了

然后在pipefd[1]这个管道里写，定义一个Writer函数

    if(id == 0)//创建成功
    {
        //子进程
        close(pipefd[0]);
        //.....IPC code，写通信代码
        //在pipefd[1]这个管道里写
        Writer(pipefd[1]);


        close(pipefd[1]);

        exit(0);//正常退出
    }

同理父进程的

    //父进程
    close(pipefd[1]);
    //.....IPC code，写通信代码
    //在pipefd[0]这个管道里写
    Reader(pipefd[0]);


    close(pipefd[0]);

//子进程
void Writer(int wfd)
{

}
//父进程
void Reader(int rfd)
{

}

Writer

//子进程
void Writer(int wfd)
{
    string s = "hello,I am child";
    pid_t self = getpid();
    int number = 0;

    char buffer[10];
    while(true)
    {
        buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了

    }
}

用到snprintf
介绍

将s和self和number放进buffer

  char buffer[100];
    while(true)
    {
        buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了
        snprintf(buffer,sizeof(buffer),"%s    pid:%d\n",s.c_str(),self);
        cout<< buffer <<endl;
        sleep(1);
    };

用cout打印测试一下，打印成功说明写入buffer成功了

等待进程少不了，子进程exit后需要回收

 //父进程
    close(pipefd[1]);
    //.....IPC code，写通信代码
    //在pipefd[0]这个管道里写
    Reader(pipefd[0]);

    //等待进程缺少不了
    pid_t rid = waitpid(id,nullptr,0);
    if(rid < 0) return 3;//等待失败了

    close(pipefd[0]);

如何把消息发送/写入给父进程

用到了write

用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道

//子进程
void Writer(int wfd)
{
    string s = "hello,I am child";
    pid_t self = getpid();
    int number = 0;
    char buffer[100];
    while(true)
    {
        buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了
        snprintf(buffer,sizeof(buffer),"%s    pid:%d  %d\n",s.c_str(),self,number++);
        //用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道
        write(wfd,buffer,strlen(buffer));
        //cout<< buffer <<endl;
        sleep(1);
    };
}

父进程该怎么读取呢

用到了read，fd是文件描述符，从特定的文件描述符里读取，放在这个buf里，buf的长度是count

这里就需要考虑到\0，因为buffer中需要\0

//父进程
void Reader(int rfd)
{
    char buffer[100];
    while(true)
    {
        buffer[0] = 0;
                                    //用sizeof是为了留个空间放\0
        ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlen
        if(n > 0)
        {
            //添加\0，因为要放在buffer数组中读取
            buffer[n]=0;
            cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;
        }
    }
}

运行结果

也会发现：为什么子进程sleep，父进程不sleep，父进程还是会跟着子进程sleep，因为父子进程是要协同的

管道本质

通信是为了更好的发送变化的数据，管道本质上是文件

所以必须要用到系统调用接口来访问管道，其是由系统管理，read和write

，操作系统相当于中介

结论：管道的特征：

1：具有血缘关系的进程进行进程间通信

2：管道只能单向通信

3：父子进程是会进程协同的，同步与互斥的--保护管道文件的数据安全

4：管道是面向字节流的

5：管道是基于文件的，而文件的生命周期是随进程的

再测试，把子进程sleep去掉，就是让子进程写快一点，父进程sleep几秒，就是让父进程读慢一点，看有什么现象

管道的四种情况

测试管道大小

把c一直往管道里写，把父进程中休眠50秒

结果差不多64kb

写端退了，测试结果

结果是：

读端正常读，写端关闭，读端就会读到0，表明读到了文件（pipe）结尾，不会被阻塞

read读取成功会返回读到的字符个数，读到结尾返回0

读到结尾父进程也就可以停止读取了，break后去把僵尸的子进程回收

break到这里

最后子进程会被waitpid回收

测试子进程一直写，父进程读一会就退出

定义一个cnt控制退出的时间

这里也要修改一下，加个sleep(5),观察，close提前关闭

结果：通过13号信号杀死

管道到的应用场景

都会变成一个进程

写一个进程池(pipe_use)

首先创建好文件

创建5个进程

channel通道的意思

cmdfd文件描述符

slaverid代表哪个子进程

把它放进vector容器里

思路步骤

管道创建

void（n），假装使用一下，要不然编译不过

创建父子进程

父进程写，子进程读

子进程要读取，就要关闭自己的写端，父进程同理

子进程中的任务

子进程pid有了管道也有了，就差在父进程添加字段了

先更改一下，在class里构造一下

添加字段

测试一下：结果：文件描述符0，1，2是默认打开，3是从管道里读，4是写入管道

把初始化改造成函数

debug测试函数，纯输入函数

第二步开始控制进程了（想让子进程做什么）

这里打印的rfd都是3，正常吗，文件描述符是可以被子进程继承的

父进程对应的写端拿到的是4-8，子进程拿到的读端fd是3

改变一下，直接从键盘（0号描述符）里读，不从管道（3）里读了，就没有管道的概念了，slaver就不用传参了，父进程通过管道写，子进程通过标准输入读

用到了dup2，将从pipefd[0]中读变成从0开始读

想让父进程固定的向管道里写入指定大小字节的内容，必须读取四个字节，四个字节四个字节的写和读，这里的管道64kb

必须读取四个字节

如果父进程不给子进程发送数据呢？阻塞等待!

开始控制子进程

生成一个随机数种子

可以随机选择任务和选择进程

cmd是任务码，测试一下，父进程控制子进程,父进程发送给子进程（通过cmdcode连续）

在Task.hpp里

要用到函数指针

main中的任务了就属于

再把任务装载进来

输出型参数用*

现在开始选择任务和进程

再把main中的任务弄成全局的

进行判断一下

测试 ,comcode和任创建的任务一致

这里的write是父进程进行写入，向子进程发送，子进程不得闲，先写到管道里，等得闲了再读

也可以轮询选择，定义一个计数器，++弄，再%等

整理一下控制代码，这里是输入型参数，只需要读

这样就可以轮询方式选择进程了，不用随机了

结果

清理收尾

思路：把所有文件的描述符都关掉

等待方式设置为0

read返回0，就是失败了，然后slaver就会调完

结束完就会exit直接退出

打印下更好显示

关闭文件描述符后sleep(10)秒，

然后这10个子进程一瞬间都应该break，然后最后到exit直接就退了，10秒结束后，父进程再回收他

测试时不弄死循环，用cnt，5秒后自动结束控制，正常退出流程

测试结果

手动控制一下

定义一个select，输入0就是退出了，判断完后，就走到了选择任务

然后直接把cmdcode改为选择的select，-1是因为是从下标0开始的，输入1就是0下标的

测试

bug的地方：

这样会有一些bug（一个子进程不是只有一个写端（每一次子进程的创建都是有继承））

按理说这样是对的，可是这样就错了

因为下面两个红线还没有关掉，它们进程了最开始的w

这样倒着回收是可以的

正确改法

修改一下

最后一个push_back的就都是父进程的写入fd，

然后加一句这个红线的，每创建子进程后都先把上一次父进程的读端fd关掉就可以了，这里很妙，因为vector一开始是空的

方便看

这里这样就可以了

管道已经完成

以上是匿名管道

原文地址：https://blog.csdn.net/2401_83427936/article/details/142467335

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：vscode快速删除一行的快捷键不管用
下一篇：c# using 声明进行资源管理

【中短文--深度学习笔记】Batchsize的选择、批量归一化、loss是否已经收敛（更新中-ing）
如果你没有任何参考，那么（即64、128、256、512、1024等）可以会更加直接和易于管理。而对于来说，batchsize大小最好<=数据集样本数*0.1。
阅读更多2024-10-13
数据在内存中的存储【下】
我们常见的浮点数：3.14159，1E10等，浮点数家族包括：float，double, long double类型。浮点数表示的范围：float.h中定义。之前我们说过浮点数在内存中无法精确保存，那
阅读更多2024-10-13
kafka-manager修改zookeeper端口号后启动仍然连接2181端口
zookeeper默认端口号修改为了2182，kafka-manager的配置文件application.conf中也已经修改了zkhosts为新的端口号，然而启动kafka-manger时报错连接连
阅读更多2024-10-13
教育培训系统小程序的设计
教师账户功能包括：系统首页，个人中心，课后习题测试管理，观看进度管理，论坛管理，网课信息管理，公告信息管理，学生管理，试卷管理，测试管理。主要技术：Java,Spring,mybatis,mysql,
阅读更多2024-10-13
使用Mockaroo生成测试数据
https://www.mockaroo.com/ Mockaroo lets you generate up to 1,000 rows of realistic test data in CSV,
阅读更多2024-10-13
提升邮件营销设计精准度秘诀，效率与效果实践
通过这些工具，营销人员可以更精准地预测用户行为，对不同用户群体进行细分，从而定向发送更为相关和个性化的邮件。此外，邮件标题是决定用户是否打开邮件的第一关键，需要足够吸引人，激发用户的好奇心和兴趣。邮件
阅读更多2024-10-13
LeetCode18.四数之和
现保持p1和p2不动，让left与right相向运动，若(long)nums[left] + (long)nums[right] + (long)nums[p1] + (long)nums[p2] =
阅读更多2024-10-13
【HTML格式PPT离线到本地浏览】
如何下载动态网站的资源呢？这里使用的是影刀RPA+脚本的方式实现。通过下载教育类网站上的PPT为例，将网上的PPT可以离线浏览。
阅读更多2024-10-13
SwiftUI 在 iOS 18 中的 ForEach 点击手势逻辑发生改变的解决
在本篇博文中，我们讨论了 iOS 18 中的 SwiftUi ForEach 视图点击逻辑和之前略有不同的情况，并给出解决方法。这可能是 SwiftUI 在 iOS 18 系统中变得更加严谨了。
阅读更多2024-10-13
研发线上事故风险解读之缓存篇
本文基于《线上事故案例集》深入探讨了缓存使用中的问题，指出尽管缓存应用门槛低，但高并发、大流量等特性使其面临技术挑战。缓存设计需预防大Key问题，包括设计阶段的预防、运营阶段的快速识别和优化阶段的拆分
阅读更多2024-10-13