进程间通信之匿名管道

这篇具有很好参考价值的文章主要介绍了进程间通信之匿名管道。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、进程间通信介绍

1.进程间为什么要进行通信?
进程间通信的是为了协调不同的进程,使之能在一个操作系统里同时运行,并相互传递、交换信息。

2.进程间通信的目的包括:
数据传输:一个进程需要将它的数据发送给另一个进程;
资源共享:多个进程间共享同样的资源;
通知事件:一个进程需要向另一个或一组进程发送消息,通知它们发生了某种事情,比如进程终止时需要通知其父进程;
进程间通信(IPC)是一组编程接口,让程序员能够协调不同的进程,使之能在一个操作系统里同时运行,并相互传递、交换信息;
进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。

3.进程间通信的分类:
(1)管道:1、匿名管道pipe;2、命名管道mkfifo
(2)System V IPC:1、System V 消息队列;2、System V 共享内存;3、System V 信号量。
(3) POSIX IPC:1、消息队列;2、共享内存;3、信号量;4、互斥量;5、条件变量;6、读写锁。
那么管道是如何进行通信的?

二、管道

什么是管道?

管道是一种通信机制,通常用于进程间的通信,它表现出来的形式将前面每一个进程的输出(stdout)直接作为下一个进程的输入(stdin)。

1.匿名管道

匿名管道是一种进程间通信机制,它仅限于本地父子进程之间通信,结构简单,类似于一根水管,一端进水另一端出水(单工)也就是只能够单向通信。匿名管道的作用之一是输出重定向。
进程间通信之匿名管道,linux
所以用匿名管道pipe通信大概分为四部:1、创建匿名管道;2、创建子进程;3、关闭不需要的文件描述符;4、进行通信。

pipe函数,linux中输入 man 2 pipe,可以查看pipe函数,如下:
进程间通信之匿名管道,linux

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int pipefd[2]);
参数
pipefd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0,失败返回-1和错误代码

1.1父进程和一个子进程之间的通信

接下来试着写一下,父进程向管道当中写“i am father”, 子进程从管道当中读出内容, 并且打印到标准输出;先创建管道, 进而创建子进程, 父子进程使用管道进行通信。

#include <iostream>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <cstdio>
#include <unistd.h>
using namespace std;

int main()
{
	//创建匿名管道
    int pipefd[2] = {0}; //文件描述符数组
    int n = pipe(pipefd);
    if (n < 0) //如果失败,则打印错误码
    {
        cout << "pipe error, " << errno << ": " << strerror(errno) << endl;
    }
    cout << "读端:" << pipefd[0] << endl;
    cout << "写端:" << pipefd[1] << endl; //打印出读写端的文件描述符
	//创建子进程
    pid_t id = fork(); //子进程中返回0,父进程返回子进程id,出错返会-1
    assert(id != -1);
    if (id == 0)
    {
        // child(子进程)
        close(pipefd[1]); //关闭不需要的文件描述符,子进程需要读,所以关闭管道写端
                          //pipefd数组中0表示读端;1表示写端
        char buffer[1024];//不管读数据还是写数据,都需要缓冲区,所以buffer相当于一个缓冲区
        while (true)
        {
            sleep(1);
            int n = read(pipefd[0], buffer, sizeof(buffer) - 1); //read函数
            //sizeof为什么-1? 从文件中读取数据到buffer中,因为c语言中字符串的结束
            //标志是'\0',而文件中的数据结束尾不需要'\0',所以buffer的内存要比读出
            //数据内存大'\0';相反,往文件中写入数据时,要注意去掉字符串末尾的'\0'//字符串末尾的'\0'在文件中会变成乱码(^@)
            if (n > 0)
            {
                buffer[n] = '\0';
                cout << "我是子进程,读取到父进程的数据: " << buffer << endl;
            }
            else if (n == 0)
            {
                cout << "我是子进程,读到了文件结尾" << buffer << endl;
                break;
            }
            else
            {
                cout << "我是子进程,读取异常" << endl;
            }
        }
        close(pipefd[0]); //关闭子进程中管道的读端
        exit(0);
    }
    // father(父进程)
    close(pipefd[0]); //父进程写入,关闭读端
    int cnt = 1; //用来记录写了多少次
    const string str = "i am father"; //要写入的内容
    char buffer[1024];
    while (true)
    {
        sleep(1);
        snprintf(buffer, sizeof(buffer), "%s, 计数器:%d", str.c_str(), cnt++);//将数据写入到buffer中
        write(pipefd[1], buffer, strlen(buffer));//再将buffer中的数据写入管道中
    }
    close(pipefd[1]); //关闭父进程中管道的写端
    
    return 0;
}

下面是一些open,write,close等函数和文件描述符等有关概念:
系统方面对文件的打开,读写和关闭(open,write,close等用法)
文件描述符
运行结果如下:
进程间通信之匿名管道,linux
由下述代码看现象:

#include <iostream>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <cstdio>
#include <unistd.h>
using namespace std;

int main()
{
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    if (n < 0)
    {
        cout << "pipe error, " << errno << ": " << strerror(errno) << endl;
    }

    pid_t id = fork();
    assert(id != -1);
    if (id == 0)
    {
        // child
        int cnt = 5;
        close(pipefd[1]);
        char buffer[1024];
        while (--cnt)
        {
            sleep(1);
            int n = read(pipefd[0], buffer, sizeof(buffer) - 1);
            if (n > 0)
            {
                buffer[n] = '\0';
                cout << buffer << endl;
            }
            else if (n == 0)
            {
                cout << "我是子进程,读到了文件结尾" << buffer << endl;
                break;
            }
            else
            {
                cout << "我是子进程,读取异常" << endl;
            }
        }
        close(pipefd[0]);
        exit(0);
    }
    // father
    close(pipefd[0]);
    int cnt = 1;
    const string str = "i am father";
    char buffer[1024];
    while (true)
    {
        sleep(1);
        snprintf(buffer, sizeof(buffer), "%s, 计数器:%d", str.c_str(), cnt++);
        write(pipefd[1], buffer, strlen(buffer));
    }
    close(pipefd[1]);
    return 0;
}

进程间通信之匿名管道,linux

由上可知:
写端一直写,读端关闭OS会杀死一直在写入的进程。
将上述代码进行小的修改,就可以得到如下现象,代码就不在展示了,四种现象如下:
1.如果read读取完毕了所有的管道数据,如果对方不发,那么就只能等待;
2.如果我们writer端将管道写满了,那么就不能再写。管道的内存是有一定大小的;
3.如果我关闭了写端,读取完毕管道数据,再读,就会read返回0,表明读到了文件结尾;
4.写端一直写,读端关闭,会发生什么呢?没有意义。OS不会维护无意义,低效率,或者浪费资源的事情。OS会杀死一直在写入的进程! OS会通过信号来终止进程,13) SIGPIPE。

1.2父进程和多个子进程之间的通信

父进程写数据,子进程读取数据,父进程和多个子进程之间的通信,首先创建管道,代码如下:

void createProcess(vector<EndPoint> &end_points)
{
    for (int i = 0; i < CHILDNUMS; ++i)
    {
        // 1.先创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0); // pipe函数成功返回0
        (void)n;        // linux中,定义一个变量,但是没使用,所以强转为void。(gcc编译可能报错)
        // 2.创建子进程
        pid_t id = fork();
        assert(id != -1); // fork失败返回-1
        if (id == 0)
        {
            // 子进程
            // 关闭不需要的文件描述符,假设父进程写,子进程读
            close(pipefd[1]); // pipe中1 为写端
            char buffer[1024];
            while (true)
            {
                //...进行读取
                ......
                
            }
            close(pipefd[0]); // 关闭读端
            exit(0);          // 关闭读端,子进程退出
        }
        // 父进程
        close(pipefd[0]);
        end_points.push_back(EndPoint(id, pipefd[1])); //将文件描述符管理起来
    }
}

其中需要注意的是创建子进程,子进程是父进程的拷贝,所以当多次fork后,子进程中含有父进程指向管道的写端,如下图:
进程间通信之匿名管道,linux
所以在创建管道时,需要关闭多余的管道,改进代码如下:

void createProcess(vector<EndPoint> &end_points)
{
    vector<int> fds;
    for (int i = 0; i < CHILDNUMS; ++i)
    {
        // 1.先创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0); // pipe函数成功返回0
        (void)n;        // linux中,定义一个变量,但是没使用,所以强转为void。(gcc编译可能报错)
        // 2.创建子进程
        pid_t id = fork();
        assert(id != -1); // fork失败返回-1
        if (id == 0)
        {
            //关闭子进程多余的fd
            for(auto &fd : fds)
                close(fd);
            // 子进程
            // 关闭不需要的文件描述符,假设父进程写,子进程读
            close(pipefd[1]); // pipe中1 为写端
            char buffer[1024];
            while (true)
            {
                //...进行读取
                ......
                
            }
            close(pipefd[0]); // 关闭读端
            exit(0);          // 关闭读端,子进程退出
        }
        // 父进程
        close(pipefd[0]);
        end_points.push_back(EndPoint(id, pipefd[1]));
        
        fds.push_back(pipefd[1]);
    }
}

完整代码如下:

#include <iostream>
#include <vector>
#include <string>
#include <string.h> //strlen
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

#define CHILDNUMS 3 // 子进程的个数
class EndPoint
{
public:
    EndPoint(pid_t id, int fd)
        : _child_id(id), _write_fd(fd)
    {
    }

public:
    pid_t _child_id;
    int _write_fd;
};
void createProcess(vector<EndPoint> &end_points)
{
    vector<int> fds;
    for (int i = 0; i < CHILDNUMS; ++i)
    {
        // 1.先创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0); // pipe函数成功返回0
        (void)n;        // linux中,定义一个变量,但是没使用,所以强转为void。(gcc编译可能报错)
        // 2.创建子进程
        pid_t id = fork();
        assert(id != -1); // fork失败返回-1
        if (id == 0)
        {
            //关闭子进程多余的fd
            for(auto &fd : fds)
                close(fd);
            // 子进程
            // 关闭不需要的文件描述符,假设父进程写,子进程读
            close(pipefd[1]); // pipe中1 为写端
            char buffer[1024];
            while (true)
            {
                int n = read(pipefd[0], buffer, sizeof(buffer) - 1);
                if (n > 0)
                {
                    buffer[n] = '\0';
                    cout << "我是pid=%d的子进程," << getpid() << ";接受到父进程的指令是:" << buffer << endl;
                }
                else if (n == 0)
                {
                    cout << "我是子进程pid=" << getpid() << ",读到了文件结尾,并且父进程写端已关闭" << endl;
                    break;
                }
                else
                {
                    cout << "我是子进程,读取异常" << endl;
                }
                sleep(1);
            }
            close(pipefd[0]); // 关闭读端
            exit(0);          // 关闭读端,子进程退出
        }
        // 父进程
        close(pipefd[0]);
        end_points.push_back(EndPoint(id, pipefd[1]));

        fds.push_back(pipefd[1]);
    }
}
void ctrlProcess(const vector<EndPoint> &end_points)
{
    // 对每个子进程下发任务
    char buffer[1024];
    int command = 0;
    int cnt = 0;
    while (true)
    {
        cnt %= end_points.size();
        cout << "输如命令号:";
        cin >> command;
        if (command == 0)
            break;
        snprintf(buffer, sizeof(buffer), "pid=%d的子进程处理%d任务", end_points[cnt]._child_id, command);
        write(end_points[cnt]._write_fd, buffer, strlen(buffer));
        ++cnt;
        sleep(1);
    }
}
void waitProcess(const vector<EndPoint> &end_points)
{
    // 需要让子进程全部退出 --- 只需要让父进程关闭所有的write_fd并且要回收子进程的僵尸状态
    for (int end = 0; end < end_points.size(); ++end)
    {
        cout << "父进程让子进程退出:" << end_points[end]._child_id << endl;
        close(end_points[end]._write_fd);

        waitpid(end_points[end]._child_id, nullptr, 0); //waitpid不需要查看子进程退出信息,所以传nullptr
        cout << "父进程回收了子进程:" << end_points[end]._child_id << endl;
    }
}
int main()
{
    cout << "命令号为0,则退出进程" << endl;
    // 需要记录子进程的pid和父进程的写端
    vector<EndPoint> end_points;
    // 1. 先进行构建控制结构, 父进程写入,子进程读取
    createProcess(end_points);
    // 2.控制每个子进程
    ctrlProcess(end_points);
    // 3. 处理所有的退出问题
    waitProcess(end_points);
    return 0;
}

运行结果如下:
进程间通信之匿名管道,linux
管道的特点:文章来源地址https://www.toymoban.com/news/detail-565217.html

  1. 只能用于具有共同祖先的进程(具有亲缘关系的进程)之间进行通信;
  2. 通常,一个管道由一个进程创建,然后该进程调用fork,此后父、子进程之间就可应用该管道;
  3. 管道提供流式服务;
  4. 一般而言,进程退出,管道释放,所以管道的生命周期随进程;
  5. 内核会对管道操作进行同步与互斥;
  6. 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道。

到了这里,关于进程间通信之匿名管道的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Linux--进程间的通信-匿名管道

    进程间通信(IPC,Interprocess Communication)是指在不同进程之间传输数据和交换信息的一种机制。它允许多个进程在同一操作系统中同时运行,并实现彼此之间的协作 。 进程间通信方式: 管道(Pipe) : 管道是最基本的进程间通信方式 ,它是一种 半双工 的通信方式,通过管

    2024年04月14日
    浏览(43)
  • [Linux]进程间通信(上篇)——匿名管道(管道原理,实现示例,端口情况探究!!)

            hello,大家好,本篇文章介绍Linux进程间的通信,包含内容有进程间通信的介绍、理解,管道的介绍使用:匿名管道,匿名管道的实现示例,匿名管道端口4种情况的探究。    目录  1️⃣进程间通信  🍙进程间通信目的 🍙进程间通信分类 🍙进程间通信的技术背景

    2024年02月14日
    浏览(51)
  • Linux通信--构建进程通信的 方案之管道(下)|使用匿名管道实现功能解耦|命名管道实现serve&client通信

    文章目录 一、管道的应用实例-父进程唤醒子进程,子进程执行某种任务 二、命名管道 1.创建一个命名管道 2.匿名管道与命名管道的区别 3.命名管道的打开规则 4.用命名管道实现serverclient通信 后续将源码上传到gitee,上传后修改链接。 管道应用的一个限制就是只能具有共同祖

    2024年02月10日
    浏览(45)
  • 【看表情包学Linux】IPC 进程间通信 | PIPE 管道 | 匿名管道 | 管道通信的原理 | 系统调用: pipe 接口

       🤣  爆笑 教程  👉 《看表情包学Linux》 🔥 CSDN 累计订阅量破千的火爆 C/C++ 教程的 2023 重制版,C 语言入门到实践的精品级趣味教程。 了解更多: 👉  \\\"不太正经\\\" 的专栏介绍  ← 试读第一章 订阅链接: 🔗 《C语言趣味教程》 ← 猛戳订阅! 目录 Ⅰ. 进程间通信(I

    2024年02月14日
    浏览(40)
  • 【探索Linux】—— 强大的命令行工具 P.14(进程间通信 | 匿名管道 | |进程池 | pipe() 函数 | mkfifo() 函数)

    当今计算机系统中,进程间通信扮演着至关重要的角色。随着计算机系统的发展和复杂性的增加,多个进程之间的协作变得更加必要和常见。进程间通信使得不同进程能够共享资源、协调工作、传输数据,并实现更加复杂和强大的功能。本文将深入探讨进程间的通信,以及管

    2024年02月05日
    浏览(72)
  • 进程间通信之匿名管道

    1.进程间为什么要进行通信? 进程间通信的是为了协调不同的进程,使之能在一个操作系统里同时运行,并相互传递、交换信息。 2.进程间通信的目的包括: 数据传输:一个进程需要将它的数据发送给另一个进程; 资源共享:多个进程间共享同样的资源; 通知事件:一个进程

    2024年02月16日
    浏览(41)
  • 【Linux从入门到精通】通信 | 管道通信(匿名管道 & 命名管道)

        本派你文章主要是对进程通信进行详解。主要内容是介绍 为什么通信、怎么进行通信。其中本篇文章主要讲解的是管道通信。希望本篇文章会对你有所帮助。 文章目录 一、进程通信简单介绍 1、1 什么是进程通信 1、2 为什么要进行通信  1、3 进程通信的方式 二、匿名管

    2024年02月09日
    浏览(46)
  • 【Linux】匿名管道实现简单进程池

    管道内部没有数据且子进程不关闭自己的写端文件fd,读端(父进程)就要阻塞等待,直到管道里有数据。 管道内部被写满了且父进程(读端)不关闭自己的读端fd,写端(子进程)写满以后就要阻塞等待。 对于写端而言,如果写端不写了且关闭了写端fd,读端就会将管道中

    2024年04月22日
    浏览(35)
  • 【Linux】匿名管道与命名管道,进程池的简易实现

    本质是先让不同的进程看到同一份资源,也就是两个进程都能对管道文件的缓冲区进行操作 这里我们pipe的时候,会使用两个文件描述符,这两个文件描述里面存的file结构体是同一个,也就是管道文件的file结构体,file结构体中存储有inode以及系统缓冲区,此时fork一个子进程

    2024年02月05日
    浏览(43)
  • 【Linux】进程通信之管道通信详解

    🍎 作者: 阿润菜菜 📖 专栏: Linux系统编程 其实管道通信是Unix中最古老的进程间通信的形式了: 管道通信是一种进程间通信的方式,它可以让一个进程的输出作为另一个进程的输入,实现数据的传输、资源的共享、事件的通知和进程的控制。 管道通信分为两种类型:匿名

    2023年04月19日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包