• 【进程间通信：管道】

    目录

    1 进程间通信介绍

    1.1 进程间通信目的

    1.2 进程间通信发展  

    1.3 进程间通信分类

     2 管道

    2.1 什么是管道

    2.2 匿名管道

    2.2.1 匿名管道的使用

     2.2.2 使用匿名管道创建进程池

    2.3 管道读写规则

    2.4 匿名管道特点

    2.5 命名管道

    2.5.1 概念

    2.5.2 使用

    1 进程间通信介绍

    1.1 进程间通信目的

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

    1.2 进程间通信发展  

    • 管道
    • System V进程间通信
    • POSIX进程间通信

    1.3 进程间通信分类

    管道

    • 匿名管道pipe
    • 命名管道
    System V IPC
    • System V 消息队列
    • System V 共享内存
    • System V 信号量
    POSIX IPC
    • 消息队列
    • 共享内存
    • 信号量
    • 互斥量
    • 条件变量
    • 读写锁

     2 管道

    2.1 什么是管道

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

    比如我们常见的命令 | , 我们知道其实我们执行的命令在linux上本质是执行一个进程，管道也分为匿名管道和命名管道，像上面这种没有名字的就叫做匿名管道。

    2.2 匿名管道

    2.2.1 匿名管道的使用

    在文件描述符得时候我们讲过，子进程会继承父进程的文件描述符，但是子进程并不会去拷贝父进程的文件，也就是子进程与父进程其实看到的是同一份文件，这就具备了进程间通信的前提：两个进程看到了同一份资源。我们就能够根据我们的需求来让父子进程完成我们的任务（比如让父进程写文件，子进程从文件中读取）

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

    我们可以用pipe函数来帮助我们创建匿名管道（大家一定要注意，使用匿名管道的前提是在父进程创建子进程前就已经把管道打开了，这样子进程才能够继承父进程的文件描述符)

     实例代码：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. using namespace std;
    9.  
    10. int main()
    11. {
    12.     
    13.     int pipefd[2]={0};
    14.     int n=pipe(pipefd);
    15.     if(n<0)
    16.     {
    17.         cout<<"error"<<":"<<strerror(errno)<
    18.         return 1;
    19.     }
    20.  
    21.     pid_t id=fork();
    22.     if(id==0)
    23.     {
    24.         //child 子进程读取，父进程写入
    25.         close(pipefd[1]);
    26.         char buffer[1024];
    27.         while(true)
    28.         {
    29.             int n=read(pipefd[0],buffer,9);
    30.             if(n>0)
    31.             {
    32.                 buffer[n]='\0';
    33.                 cout<<"child :"<
    34.             }
    35.             else if(n==0)
    36.             {
    37.                 cout<<"read file end"<
    38.             }
    39.             else 
    40.             {
    41.                 cout<<"read error"<
    42.             }
    43.         }
    44.  
    45.         close(pipefd[0]);
    46.         exit(0);
    47.     }
    48.  
    49.     //parent 子进程读取，父进程写入
    50.     close(pipefd[0]);
    51.     const char* str="hello bit";
    52.     while(true)
    53.     {
    54.         write(pipefd[1],str,strlen(str));
    55.     }
    56.     close(pipefd[1]);
    57.  
    58.     int status=0;
    59.     waitpid(id,&status,0);
    60.     cout<<"singal:"<<(status&0x7f)<
    61.     return 0;
    62. }

    这样我们就编写完成了一份基本的用匿名管道进行通信的方法。

    代码中值得注意的细节有：

    1. 系统规定数组下标为0表示读端，数组下标为1表示写端。
    2. 父子进程一个完成写入，一个完成读取，在写入前应当关闭读端，同理在读取前应当关闭写段。

     2.2.2 使用匿名管道创建进程池

    我们可以用一个匿名管道来做一些比较优雅的事情：比如创建一个进程池，用一个父进程管理多个子进程：

    contralProcess.cc:

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include "Task.hpp"
    9. using namespace std;
    10.  
    11. const int gnum = 3;
    12. Task t;
    13.  
    14. class EndPoint
    15. {
    16. private:
    17.     static int number;
    18. public:
    19.     pid_t _child_id;
    20.     int _write_fd;
    21.     std::string processname;
    22. public:
    23.     EndPoint(int id, int fd) : _child_id(id), _write_fd(fd)
    24.     {
    25.         //process-0[pid:fd]
    26.         char namebuffer[64];
    27.         snprintf(namebuffer, sizeof(namebuffer), "process-%d[%d:%d]", number++, _child_id, _write_fd);
    28.         processname = namebuffer;
    29.     }
    30.     std::string name() const
    31.     {
    32.         return processname;
    33.     }
    34.     ~EndPoint()
    35.     {
    36.     }
    37. };
    38.  
    39. int EndPoint::number = 0;
    40.  
    41. // 子进程要执行的方法
    42. void WaitCommand()
    43. {
    44.     while (true)
    45.     {
    46.         int command = 0;
    47.         int n = read(0, &command, sizeof(int));
    48.         if (n == sizeof(int))
    49.         {
    50.             t.Execute(command);
    51.         }
    52.         else if (n == 0)
    53.         {
    54.             std::cout << "父进程让我退出，我就退出了: " << getpid() << std::endl; 
    55.             break;
    56.         }
    57.         else
    58.         {
    59.             break;
    60.         }
    61.     }
    62. }
    63.  
    64. void createProcesses(vector *end_points)
    65. {
    66.     vector<int> fds;
    67.     for (int i = 0; i < gnum; i++)
    68.     {
    69.         // 1.1 创建管道
    70.         int pipefd[2] = {0};
    71.         int n = pipe(pipefd);
    72.         assert(n == 0);
    73.         (void)n;
    74.  
    75.         // 1.2 创建进程
    76.         pid_t id = fork();
    77.         assert(id != -1);
    78.         // 一定是子进程
    79.         if (id == 0)
    80.         {
    81.             for(auto &fd : fds) close(fd);
    82.  
    83.             
    84.             // 1.3 关闭不要的fd
    85.             close(pipefd[1]);
    86.             // 我们期望，所有的子进程读取"指令"的时候，都从标准输入读取
    87.             // 1.3.1 输入重定向，可以不做
    88.             dup2(pipefd[0], 0);
    89.             // 1.3.2 子进程开始等待获取命令
    90.             WaitCommand();
    91.             close(pipefd[0]);
    92.             exit(0);
    93.         }
    94.  
    95.         // 一定是父进程
    96.         //  1.3 关闭不要的fd
    97.         close(pipefd[0]);
    98.  
    99.         // 1.4 将新的子进程和他的管道写端，构建对象
    100.         end_points->push_back(EndPoint(id, pipefd[1]));
    101.  
    102.         fds.push_back(pipefd[1]);
    103.     }
    104. }
    105.  
    106.  
    107. int ShowBoard()
    108. {
    109.     std::cout << "##########################################" << std::endl;
    110.     std::cout << "|   0. 执行日志任务   1. 执行数据库任务    |" << std::endl;
    111.     std::cout << "|   2. 执行请求任务   3. 退出             |" << std::endl;
    112.     std::cout << "##########################################" << std::endl;
    113.     std::cout << "请选择# ";
    114.     int command = 0;
    115.     std::cin >> command;
    116.     return command;
    117. }
    118.  
    119. void ctrlProcess(const vector &end_points)
    120. {
    121.     // 2.1 我们可以写成自动化的，也可以搞成交互式的
    122.     int num = 0;
    123.     int cnt = 0;
    124.     while(true)
    125.     {
    126.         //1. 选择任务
    127.         int command = ShowBoard();
    128.         if(command == 3) break;
    129.         if(command < 0 || command > 2) continue;
    130.         
    131.         //2. 选择进程
    132.         int index = cnt++;
    133.         cnt %= end_points.size();
    134.         std::string name = end_points[index].name();
    135.         std::cout << "选择了进程: " <<  name << " | 处理任务: " << command << std::endl;
    136.  
    137.         //3. 下发任务
    138.         write(end_points[index]._write_fd, &command, sizeof(command));
    139.  
    140.         sleep(1);
    141.     }
    142. }
    143.  
    144. void waitProcess(const vector &end_points)
    145. {
    146.     // 1. 我们需要让子进程全部退出 --- 只需要让父进程关闭所有的write fd就可以了！
    147.     // for(const auto &ep : end_points) 
    148.     // for(int end = end_points.size() - 1; end >= 0; end--)
    149.     for(int end = 0; end < end_points.size(); end++)
    150.     {
    151.         std::cout << "父进程让子进程退出:" << end_points[end]._child_id << std::endl;
    152.         close(end_points[end]._write_fd);
    153.  
    154.         waitpid(end_points[end]._child_id, nullptr, 0);
    155.         std::cout << "父进程回收了子进程:" << end_points[end]._child_id << std::endl;
    156.     } 
    157.     sleep(10);
    158.  
    159.     // 2. 父进程要回收子进程的僵尸状态
    160.     // for(const auto &ep : end_points) waitpid(ep._child_id, nullptr, 0);
    161.     // std::cout << "父进程回收了所有的子进程" << std::endl;
    162.     // sleep(10);
    163. }
    164.  
    165.  
    166.  
    167. int main()
    168. {
    169.     vector end_points;
    170.     // 1. 先进行构建控制结构, 父进程写入，子进程读取 ， bug?
    171.     createProcesses(&end_points);
    172.  
    173.     // 2. 我们的得到了什么？end_points
    174.     ctrlProcess(end_points);
    175.  
    176.     // 3. 处理所有的退出问题
    177.     waitProcess(end_points);
    178.     return 0;
    179. }

    Task.hpp:

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. // typedef std::function func_t;
    9.  
    10. typedef void (*fun_t)(); //函数指针
    11.  
    12. void PrintLog()
    13. {
    14.     std::cout << "pid: "<< getpid() << ", 打印日志任务，正在被执行..." << std::endl;
    15. }
    16.  
    17. void InsertMySQL()
    18. {
    19.     std::cout << "执行数据库任务，正在被执行..." << std::endl;
    20. }
    21.  
    22. void NetRequest()
    23. {
    24.     std::cout << "执行网络请求任务，正在被执行..." << std::endl;
    25. }
    26.  
    27.  
    28. //约定，每一个command都必须是4字节
    29. #define COMMAND_LOG 0
    30. #define COMMAND_MYSQL 1
    31. #define COMMAND_REQEUST 2
    32.  
    33. class Task
    34. {
    35. public:
    36.     Task()
    37.     {
    38.         funcs.push_back(PrintLog);
    39.         funcs.push_back(InsertMySQL);
    40.         funcs.push_back(NetRequest);
    41.     }
    42.     void Execute(int command)
    43.     {
    44.         if(command >= 0 && command < funcs.size()) funcs[command]();
    45.     }
    46.     ~Task()
    47.     {}
    48. public:
    49.     std::vector<fun_t> funcs;
    50. };

    不知道大家注意到了没有一个问题：我们在创建子进程时先做的工作是先从vector中读取数据来关闭的，这个vector中存放的究竟是什么呢？

     我们来思考下：当我们父进程第一次fork后，父进程使用了下标为4的文件描述符，第一个子进程使用了下标为3的文件描述符，父进程通过pipefd[1]向第一个管道里面写入数据，子进程通过pipefd[0]在管道里面读取数据，但是当我们第二次创建子进程的时候子进程会继承父进程的文件描述符，也就是说，第二次的子进程居然也继承了父进程第一次打开的下标为4的文件描述符，那么这样做的危害是什么？如果我们通过先的关闭第一个管道的写端，然后再回收第一个子进程时，第一个子进程会一直阻塞在那里，为什么呢？因为第二个子进程中继承父进程的写端还指向第一个子进程的读端，也就是我们如果只先关闭了第一个管道的写端是不行的，第一个子进程并没有结束，因为他的读端还指向后面所有的子进程，这就导致第一个子进程回收时一直阻塞在那里。后面进程的分析方法同理：

     解决方法有：我们可以先统一将所有管道的写端关闭，然后再一个一个回收。这样所有进程的写端都被关闭了，自然就成功退出了。还可以从最后一个管道的写端开始关闭，边关闭边回收，由于最后一个子进程的读端只指向最后一个管道的写端，所以能够正常退出。

    但是这样写终归治标不治本，这时因为fork创建子进程时子进程已经把前面进程的文件描述符给继承下来了，有没有方法在创建子进程是就把继承父进程的文件描述符给关闭了呢？答案是有的，上面我们提到的vector就是能够很好的处理，我们每次创建了子进程后，就把对应的管道的写端给保留下来（保留到vector中)，然后每次创建时就先关闭之前继承的文件描述符给关闭就行了。（这里面的关系有点复杂，大家一定要自己下去好好总结)

    所以，看待管道，就如同看待文件一样！管道的使用和文件一致，迎合了 “Linux 一切皆文件思想 ” 。

    2.3 管道读写规则

    当没有数据可读时：

    • O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
    • O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
    当管道满的时候：
    • O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
    • O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
    • 如果所有管道写端对应的文件描述符被关闭，则read返回0
    • 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出
    • 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。
    • 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

     前面的都很好理解，这里提一嘴什么是原子性：原子性就是假如我们往管道中写入一句"hello world"时，如果能够将其完整写进去时进行写入，否则就不进行写入，也就是程序的执行只能够有两种结果：数据全部写入和数据全部都没写入，不存在着写入一半的情况。

    2.4 匿名管道特点

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

     

    2.5 命名管道

    2.5.1 概念

    管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。
    如果我们想在不相关的进程之间交换数据，可以使用 FIFO 文件来做这项工作，它经常被称为命名管道。命名管道是一种特殊类型的文件。

    2.5.2 使用

    我们知道匿名管道是具有血缘关系的进程建立通信的方式，而命名管道则是可以让没有血缘关系的进程建立通信。那么如何让没有血缘关系的进程看到同一份资源呢？

    我们首先来看看这样一个命令：

     我们通过mkfifo命令创建了一个叫做fifo的管道文件，当我们将字符串输出重定向到该文件时我们发现光标卡在了这里不动了，而当我们去读取的时候才会显现，当我们终止掉时两边都已经结束了：

     这是在命令行上创建的命名管道。而这种管道是内存级别的文件，是不会刷新到磁盘上的。生成的命名管道文件只是内核缓冲区的一个标识，用于让多个进程找到同一个缓冲区。匿名管道和命名管道的本质都是内核中的一块缓冲区。再来回答如何让不同的进程看到同一份资源，我们可以采用文件路径+文件名来作为唯一标识该文件的方法来创建文件作为一个命名管道。

    除了用命令行式的方法，我们还可以用系统调用：

    int mkfifo(const char *filename,mode_t mode);

     通过这个我们可以实现一个简单的服务端与客户端进行通信的程序：

    server.cc:

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10.  
    11.  
    12. int main()
    13. {
    14.     const string fileName("myfile");
    15.     umask(0);
    16.     int n=mkfifo(fileName.c_str(),0666);
    17.     if(n<0)
    18.     {
    19.         cerr<<"strerrno:"<strerror(errno)<
    20.         return 1;
    21.     }
    22.  
    23.     cout<<"server creat fifo success"<
    24.     int rop=open(fileName.c_str(), O_RDONLY);
    25.     if(rop<0)
    26.     {
    27.         cerr<<"strerrno:"<strerror(errno)<
    28.         return 1;
    29.     }
    30.     cout<<"server open fifo success,begin ipc"<
    31.     char buffer[1024];
    32.     while(true)
    33.     {
    34.         buffer[0]=0;
    35.         int n=read(rop,buffer,sizeof(buffer)-1);
    36.         if(n>0)
    37.         {
    38.             buffer[n]=0;
    39.             cout<
    40.         }
    41.         else if(n==0)
    42.         {
    43.             cout<<"client exit,server also exit"<
    44.             break;
    45.         }
    46.         else
    47.         {
    48.             cerr<<"strerrno:"<strerror(errno)<
    49.             return 1;
    50.         }
    51.     }
    52.     close(rop);
    53.     unlink(fileName.c_str());
    54.     return 0;
    55. }

    client.cc:

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10. int main()
    11. {
    12.     const string fileName("myfile");
    13.     int wop=open(fileName.c_str(),O_WRONLY);
    14.     if(wop<0)
    15.     {
    16.         cerr<<"strerrno:"<strerror(errno)<
    17.         return 1;
    18.     }
    19.     string myinfo;
    20.     while(true)
    21.     {
    22.         cout<<"请输入你的消息"<
    23.         getline(cin,myinfo);
    24.         write(wop,myinfo.c_str(),myinfo.size());
    25.         myinfo[strlen(myinfo.c_str())-1]=0;
    26.     }
    27.     close(wop);
    28.     return 0;
    29. }

    Makefile:

    1. .PHONY:all
    2. all:client server
    3.  
    4. client:client.cc
    5. 	g++ -o $@ $^ -std=c++11
    6. server:server.cc
    7. 	g++ -o $@ $^ -std=c++11
    8.  
    9. .PHONY:clean
    10. clean:
    11. 	rm -rf client server

    效果：

    由于我们是在服务端建立好的匿名管道，所以当我们退出时最好在服务端中干掉管道文件。

    顺便提问一下：多个进程在通过管道通信时，删除管道文件则无法继续通信吗？

    显然不是的，由于管道文件只是起一个标识作用，之前已经打开管道的进程依旧可以正常通信。

  • 相关阅读:
    Maven 命令行环境
    Linux系统编程学习 NO.8 ——make和Makefile、进度条程序
    C/C++微实践 - 分形蕨类树叶
    『heqingchun-ubuntu系统下Qt报错connot find -lGL解决方法』
    bodipy荧光标记染料BDP FL alkyne/炔基炔烃，CAS:302795-84-2、2006345-30-6
    PX4飞行测试
    低代码平台自动化办公--异行星低代码平台为例（三）
    递归时间复杂度分析 && master公式
    简化开发流程，消除重复任务：refine 帮您轻松搞定 | 开源日报 No.63
    [附源码]计算机毕业设计JAVA车辆违章信息管理系统
  • 原文地址：https://blog.csdn.net/m0_68872612/article/details/130131513