进程间通信--匿名管道

熬夜苦读学习2025-03-17 12:55

进程间通信介绍

进程间通信目的

  • 数据传输：一个进程需要将它的数据发送给另一个进程
  • 资源共享：多个进程之间共享同样的资源。
  • 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
  • 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

管道

什么是管道

管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个"管道"如：

用fork来共享管道原理

站在文件描述符角度-深度理解管道 （内存级）

左边是进程管理，右边是文件管理，进程通过全局变量能找到文件描述符标，也就找到了对应的file文件也能打开磁盘上的文件拷贝到缓冲区里进行读写，父进程创建子进程，发生写实拷贝，类似于浅拷贝，此时不做文件操作，文件描述符里面的对于关系和父进程一样，struc_file没有关闭，因为父进程还在， struc_file的对应的引用计数不为0就一定不会关闭，既然访问的同一个struc_file，也可以同时访问其中的file文件，通过缓冲区可以进行文件的读写

  1. 父进程通过读写两种方式打开内存级的文件返回给上层完成管道的创建
  2. 子进程继承父进程的文件描述符表，发生浅拷贝，也能拿到父进程以读写打开的管道文件
  3. 父子都看得到，让父子单向通信，父进程写，子进程读，各自关闭掉自己不需要的文件描述符

这个是管道是OS单独设计的，得配上单独的系统调用：pipe 内存级的，不需要文件路径，没有文件名，所以叫匿名管道，++那我们怎么保证，两个进程打开的是同一个管道的？++

++子进程继承了父进程的文件描述符表++

站在内核角度-管道本质

匿名管道

cpp 复制代码 
#include <unistd.h>
功能:创建⼀⽆名管道
原型
int pipe(int fd[2]);
参数
fd：⽂件描述符数组,其中fd[0]表⽰读端, fd[1]表⽰写端
返回值:成功返回0，失败返回错误代码
cpp 复制代码 
#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{
    int fds[2]={0};

    int n=pipe(fds);
    if(n<0)
    {
        cerr<<"Pipe error"<<endl;
        return 1;
    }
    cout<<"fds[0]"<<fds[0]<<endl;
    cout<<"fds[1]"<<fds[1]<<endl;
   
    return 0;
}

0，1，2被三个标准占用了，从3，4开始

父写子读，实现通信

cpp 复制代码 
#include<iostream>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/types.h>
#include<cstring>
using namespace std;

void ChildWrite(int fd)
{
char buffer[1024];
int cnt=0;
while(true)
{
snprintf(buffer,sizeof(buffer),"I am child,pid:%d cnt:%d\n",getpid(),cnt++); 
write(fd,buffer,strlen(buffer));
sleep(1);
}
}
void FatherRead(int fd)
{
    char buffer[1024];
 while(true)
 {
    buffer[0]=0;
    ssize_t n=read(fd,buffer,sizeof(buffer)-1);
    if(n>0)
    {
        buffer[n]=0;
        cout<<"child says: "<<buffer<<endl;
    }
 }
}
int main()
{  //1.创建管道
    int fds[2]={0}; //fds[0]读端，fds[1]写端

    int n=pipe(fds);
    if(n<0)
    {
        cerr<<"Pipe error"<<endl;
        return 1;
    }
    cout<<"fds[0]"<<fds[0]<<endl;
    cout<<"fds[1]"<<fds[1]<<endl;
   //3.创建子进程 f->r c->w
    pid_t id=fork();
  if(id==0)
  {
    //child
    close(fds[0]); //关闭读端
    ChildWrite(fds[1]);
    close(fds[1]);
    exit(0);
  }
close(fds[1]); //关闭写端
FatherRead(fds[0]);
waitpid(id,nullptr,0);
close(fds[0]);
    return 0;
}

父进程写的cnt在不断变化，子进程能读到，说明实现了管道通信

五种特性

1.匿名管道，只能用来进行具有血缘关系的进程进行进程间通信(常用父与子，如上述代码)

2.管道文件，自带同步机制（父子进程进行IO同时进行，一个读一个写，不管是父快还是子快，父不断写，子read读不到会阻塞住直到读到为止）

3.管道是面向字节流的

4.管道是单向通信的（要么父写子读，要么子写父读）

  1. （管道）文件的生命周期随进程

4种通信情况

1.写慢，读快------>读端阻塞等待写端(进程)

2.写快，读慢------>缓冲区写满了，写要阻塞等待读端

3.写关，读开------>read会读到返回值0，表示文件结尾

cpp 复制代码 
//写一条就关
void ChildWrite(int fd)
{
char buffer[1024];
int cnt=0;
while(true)
{
snprintf(buffer,sizeof(buffer),"I am child,pid:%d cnt:%d\n",getpid(),cnt++); 
write(fd,buffer,strlen(buffer));
sleep(1);
break;
}
}
//观察n的返回值
void FatherRead(int fd)
{
    char buffer[1024];
 while(true)
 {
    buffer[0]=0;
    ssize_t n=read(fd,buffer,sizeof(buffer)-1);
    if(n>0)
    {
        buffer[n]=0;
        cout<<"child says: "<<buffer<<endl;
    }
    else
    {
      cout<< "n:"<<n<<endl;
    }
 }
}

4.读关，写开------->写端再写没有意义，OS会杀掉写端进程

cpp 复制代码 
#include<iostream>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/types.h>
#include<cstring>
using namespace std;

void ChildWrite(int fd)
{
char buffer[1024];
int cnt=0;
while(true)
{
snprintf(buffer,sizeof(buffer),"I am child,pid:%d cnt:%d\n",getpid(),cnt++); 
write(fd,buffer,strlen(buffer));
sleep(1);
}
}
void FatherRead(int fd)
{
    char buffer[1024];
 while(true)
 {
    buffer[0]=0;
    ssize_t n=read(fd,buffer,sizeof(buffer)-1);
    if(n>0)
    {
        buffer[n]=0;
        cout<<"child says: "<<buffer<<endl;
    }
    else
    {
      cout<< "n:"<<n<<endl;
      sleep(4);
    }
    break;
 }
}
int main()
{  //1.创建管道
    int fds[2]={0}; //fds[0]读端，fds[1]写端

    int n=pipe(fds);
    if(n<0)
    {
        cerr<<"Pipe error"<<endl;
        return 1;
    } 
    cout<<"fds[0]"<<fds[0]<<endl;
    cout<<"fds[1]"<<fds[1]<<endl;
   //3.创建子进程 f->r c->w
    pid_t id=fork();
  if(id==0)
  {
    //child
    close(fds[0]); //关闭读端
    ChildWrite(fds[1]);
    close(fds[1]);
    exit(0);
  }
close(fds[1]); //关闭写端
FatherRead(fds[0]);
close(fds[0]);
  int status;
int ret=waitpid(id,&status,0);
//获取到子进程的退出状态
if(ret>0)
{
  printf("child code: %d exited  status: %d\n",(status)>>8&0xff,(status)&0x7f);
}
return 0;
}

发送异常信号13 SIGPIPE

基于匿名管道----进程池

父进程创建多个子进程，用匿名管道分派任务

1.构建进程链，为进程池做准备

cpp 复制代码 
#ifndef __PROCESS__POOL_HPP__
#define __PROCESS__POOL_HPP__
#include <iostream>
#include <vector>
#include <unistd.h>
#include<cstdlib>
using namespace std;
const int gdefaultnum = 5; // 要创建几个进程
// 先描述 单个进程
class Channel
{
public:
    Channel() {}
    ~Channel() {}

private:
    int _wfd;
};

// 在组织  进程链
class ChannelManager
{
public:
    ChannelManager() {}
    ~ChannelManager() {}

private:
    vector<Channel> _channels;
};

2.创建进程池，提供管道条件

cpp 复制代码 
// 进程池
class ProcessPool
{
public:
    ProcessPool(int num) : _process_num(num) {}
    ~ProcessPool() {}
    bool Create()
    {
        int pipefd[2] = {0};
        for (int i = 0; i < _process_num; i++)
        {
            // 1.创建管道

            int n = pipe(pipefd);
            if (n < 0)
                return false;
        }
        // 2.创建子进程  各自关闭不需要的文件描述符
        pid_t id = fork();
        if (id < 0)
            return false;
        else if (id == 0)
        {
            // 子进程 --->读
            // 3.关闭不需要的文件描述符
            close(pipefd[1]);
            exit(0);
        }
        else
        {
            // 父进程 --->写
            // 3.关闭不需要的文件描述符
            close(pipefd[0]);
        }
        return true;
    }

private:
    ChannelManager _cm; // 进程链
    int _process_num;   // 进程个数
};

3.父子各自打印验证是否通信

cpp 复制代码 
void BuildChannel(int wfd, pid_t subid)
    {
        _channels.emplace_back(wfd, subid);
        // Channel c(wfd,subid);
        // _channels.push_back(c);
    }
  
void Print()
{
    for(auto  &chnnel : _channels)
    {
cout<<chnnel.Name()<<endl;
    }
}

void Work(int rfd)
    {
        while (true)
        {
            cout << "我是子进程，我的rfd是：" << rfd << endl;
            sleep(2);
        }
    }
cpp 复制代码 
//ProcessPool.hpp
#ifndef __PROCESS__POOL_HPP__
#define __PROCESS__POOL_HPP__
#include <iostream>
#include <vector>
#include <unistd.h>
#include <cstdlib>
using namespace std;
const int gdefaultnum = 5; // 要创建几个进程
// 先描述 单个进程
class Channel
{
public:
    Channel(int fd, pid_t id) : _wfd(fd), _subid(id) { _name = "chnnel-" + std::to_string(_wfd) + "-" + std::to_string(_subid); }
    ~Channel() {}
    int Fd(){return  _wfd;}
    pid_t Subid(){return  _subid;}
    string Name(){return  _name;}
private:
    int _wfd;
    pid_t _subid;
    std::string _name;
};

// 在组织  进程链
class ChannelManager
{
public:
    ChannelManager() {}
    ~ChannelManager() {}
    void BuildChannel(int wfd, pid_t subid)
    {
        _channels.emplace_back(wfd, subid);
        // Channel c(wfd,subid);
        // _channels.push_back(c);
    }
  
void Print()
{
    for(auto  &chnnel : _channels)
    {
cout<<chnnel.Name()<<endl;
    }
}
private:
    vector<Channel> _channels;
};

// 进程池
class ProcessPool
{
public:
    ProcessPool(int num) : _process_num(num) {}
    ~ProcessPool() {}

    void Work(int rfd)
    {
        while (true)
        {
            cout << "我是子进程，我的rfd是：" << rfd << endl;
            sleep(2);
        }
    }
    bool Create()
    {

        for (int i = 0; i < _process_num; i++)
        {
            int pipefd[2] = {0};
            // 1.创建管道

            int n = pipe(pipefd);
            if (n < 0)
                return false;

            // 2.创建子进程  父子各自关闭不需要的文件描述符
            pid_t id = fork();
            if (id < 0)
                return false;
            else if (id == 0)
            {
                // 子进程 --->读
                // 3.关闭不需要的文件描述符
                close(pipefd[1]);
                Work(pipefd[0]);
                exit(0);
            }
            else
            {
                // 父进程 --->写
                // 3.关闭不需要的文件描述符
                close(pipefd[0]);
                _cm.BuildChannel(pipefd[1], id);
                close(pipefd[1]);
            }
            
        }
        return true;
    }
  void Debug()
  {
    _cm.Print();
  }
private:
    ChannelManager _cm; // 进程链
    int _process_num;   // 进程个数
};

#endif
cpp 复制代码 
//Main.cc

#include"ProcessPool.hpp"

int main()
{
    ProcessPool pp(gdefaultnum);
    //创建进程池
    pp.Create();
    //打印进程池
    pp.Debug();
    sleep(1000);
    return 0;
}

实现通信

4.分配任务，子写父读

cpp 复制代码 
 void Work(int rfd)
    {
        while (true)
        {
            int code = 0;
            ssize_t n = read(rfd, &code, sizeof(code));
            if (n > 0)
            {
                if (n == sizeof(code))
                {
                    continue;
                }
                cout << "子进程[]"<<getpid()<<"]收到一个任务码:" << code << endl;
            }
            else if (n == 0)
            {
                cout << "子进程退出" << endl;
                break;
            }
            else
            {
                // 读失败
                cout << "读取错误" << endl;
                break;
            }
        }
    }
 void PushTack(int taskcode)
    {
        // 1.选择一个子进程，采用轮询，防止负载均衡和负载不均衡
        auto &c = _cm.Select();
        cout << "选择一个子进程：" << c.Name() << endl;
        // 2.发送任务
        c.Send(taskcode);
        cout << "发送了一个任务码：" << taskcode << endl;
    }

完整代码

cpp 复制代码 
//ProcessPool.hpp
#ifndef __PROCESS__POOL_HPP__
#define __PROCESS__POOL_HPP__
#include <iostream>
#include <vector>
#include <unistd.h>
#include <cstdlib>
using namespace std;
const int gdefaultnum = 5; // 要创建几个进程
// 先描述 单个进程
class Channel
{
public:
    Channel(int fd, pid_t id) : _wfd(fd), _subid(id) { _name = "chnnel-" + std::to_string(_wfd) + "-" + std::to_string(_subid); }
    ~Channel() {}
    int Fd() { return _wfd; }
    pid_t Subid() { return _subid; }
    string Name() { return _name; }
    void Send(int code)
    {
        int n = write(_wfd, &code, sizeof(code));
        (void)n;
    }

private:
    int _wfd;
    pid_t _subid;
    std::string _name;
};

// 在组织  进程链
class ChannelManager
{
public:
    ChannelManager() : _next(0) {}
    ~ChannelManager() {}
    void BuildChannel(int wfd, pid_t subid)
    {
        _channels.emplace_back(wfd, subid);
        // Channel c(wfd,subid);
        // _channels.push_back(c);
    }
    // 轮询
    Channel &Select()
    {
        auto &c = _channels[_next];
        _next++;
        _next %= _channels.size();
        return c;
    }
    void Print()
    {
        for (auto &chnnel : _channels)
        {
            cout << chnnel.Name() << endl;
        }
    }

private:
    vector<Channel> _channels;
    int _next;
};

// 进程池
class ProcessPool
{
public:
    ProcessPool(int num) : _process_num(num) {}
    ~ProcessPool() {}

    void Work(int rfd)
    {
        while (true)
        {
            int code = 0;
            ssize_t n = read(rfd, &code, sizeof(code));
            if (n > 0)
            {
                if (n == sizeof(code))
                {
                    continue;
                }
                cout << "子进程[]"<<getpid()<<"]收到一个任务码:" << code << endl;
            }
            else if (n == 0)
            {
                cout << "子进程退出" << endl;
                break;
            }
            else
            {
                // 读失败
                cout << "读取错误" << endl;
                break;
            }
        }
    }
    bool Create()
    {

        for (int i = 0; i < _process_num; i++)
        {
            int pipefd[2] = {0};
            // 1.创建管道

            int n = pipe(pipefd);
            if (n < 0)
                return false;

            // 2.创建子进程  父子各自关闭不需要的文件描述符
            pid_t id = fork();
            if (id < 0)
                return false;
            else if (id == 0)
            {
                // 子进程 --->读
                // 3.关闭不需要的文件描述符
                close(pipefd[1]);
                Work(pipefd[0]);
                exit(0);
            }
            else
            {
                // 父进程 --->写
                // 3.关闭不需要的文件描述符
                close(pipefd[0]);
                _cm.BuildChannel(pipefd[1], id);
                close(pipefd[1]);
            }
        }
        return true;
    }

    void Debug()
    {
        _cm.Print();
    }
    void PushTack(int taskcode)
    {
        // 1.选择一个子进程，采用轮询，防止负载均衡和负载不均衡
        auto &c = _cm.Select();
        cout << "选择一个子进程：" << c.Name() << endl;
        // 2.发送任务
        c.Send(taskcode);
        cout << "发送了一个任务码：" << taskcode << endl;
    }

private:
    ChannelManager _cm; // 进程链
    int _process_num;   // 进程个数
};

#endif
cpp 复制代码 
//Main.cc

#include"ProcessPool.hpp"

int main()
{
    ProcessPool pp(gdefaultnum);
    //创建进程池
    pp.Create();
    //打印进程池
    //pp.Debug();
    int task_code = 1;
   while(true)
   {
    pp.PushTack(task_code++);
    sleep(1);
   }
    return 0;
}

创建进程池后，OS关闭了没有意义的管道，每次选择一个管道接受消息

相关推荐
用户0328472220709 小时前
如何搭建本地yum源(上)
运维
大树883 天前
金刚石散热越强，管路越先见顶
大数据·运维·服务器·人工智能·ai
摇滚侠3 天前
Linux CentOS7 rpm 安装 MySQL 5.7
linux·运维·mysql
霸道流氓气质3 天前
领域驱动设计（DDD）在 Spring Boot 微服务中的实践指南
运维·spring boot·微服务
小宇宙Zz3 天前
Maven依赖冲突
java·服务器·maven
Inhand陈工3 天前
基于台达PLC与映翰通IG502的智慧水产养殖精准投喂与远程运维解决方案
运维·人工智能·物联网·阿里云·信息与通信
酣大智3 天前
ARP代理--工作原理
运维·网络·arp·arp代理
shushangyun_3 天前
2026年快消品B2B系统推荐：支持终端门店订货、促销政策自动化的工具？
java·运维·网络·数据库·人工智能·spring·自动化
古城小栈3 天前
Unix 与 Linux 异同小叙
linux·服务器·unix
施努卡机器视觉3 天前
SNK施努卡侧滑门锁上滑轮总成自动化装配线，从零件到组件，全流程精密制造方案
运维·自动化·制造
热门推荐
012026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04【AI】2026 年具身智能模型和世界模型总结05GitHub 镜像站点06AI科技热点日报 | 2026年6月1日07AI一周事件 · 2026-06-03 至 2026-06-09082026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？09Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析10上线仅72小时被强制下架：Claude Fable 5 的短命