1. 初识进程间通信 ?1.1 进程间通信的目的数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止 时要通知父进程）进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另 一个进程的所有陷入和异常，并能够及时知道它的状态改变1.2 为什么要有进程间通信 ❓
为了实现两个或者多个进程实现数据层面的交互，因为进程独立性的存在，导致进程通信的成本比较高
很多场景下需要多个进程协同工作来完成要求。如下：
|) 将输出传递给 grep 命令。grep 用于搜索指定的字符串。grep Hello: 这个命令搜索包含 "Hello" 的行。1.3 进程间通信的方式管道（通过文件系统通信）
匿名管道pipe命名管道System V IPC （聚焦在本地通信）
System V 消息队列System V 共享内存System V 信号量POSIX IPC （让通信可以跨主机）
消息队列共享内存信号量互斥量条件变量读写锁注意：
System V 标准需要重新构建操作系统代码来实现进程通信，比较繁琐。在 System V 标准出现之前，而「管道通信」是直接复用现有操作系统的代码现在本地通信已经被网络通信取代，所以进程间通信方式只重点介绍管道通信和共享内存通信知识补充：
（1）进程间通信的本质：必须让不同的进程看到同一份“资源”（资源：特定形式的内存空间）
（2）这个资源谁提供？一般是操作系统
为什么不是我们两个进程中的一个呢？假设一个进程提供，这个资源属于谁？这个进程独有，破坏进程独立性，所以要借用第三方空间（3）我们进程访问这个空间，进行通信，本质就是访问操作系统！
进程代表的就是用户，资源从创建，使用（一般），释放--系统调用接口！2. 匿名管道 ? 2.1 什么是管道进程可以通过 读/写 的方式打开同一个文件，操作系统会创建两个不同的文件对象 file，但是文件对象 file 中的内核级缓冲区、操作方法集合等并不会额外创建，而是一个文件的文件对象的内核级缓冲区、操作方法集合等通过指针直接指向另一个文件的内核级缓冲区、操作方法集合等。
这样以读方式打开的文件和以写方式打开的文件共用一个 内核级缓冲区
所以根据上述原理，父子进程可以看到同一份共享资源：被打开文件的内核级缓冲区。父进程向被打开文件的内核级缓冲区写入，子进程从被打开文件的内核级缓冲区读取，这样就实现了进程通信！
这里也将被打开文件的内核级缓冲区称为 「 管道文件」，而这种由文件系统提供公共资源的进程间通信，就叫做「 管道 」注意：
当父进程要传输数据给子进程时，就可以只使用以写方式打开的文件的管道文件，关闭以读方式打开的文件，同样的，子进程只是用以读方式打开的文件的管道文件，关闭掉以写方式打开的文件。父进程向以写方式打开的文件的管道文件写入，子进程再从以读方式打开的文件的管道文件读取，从而实现管道通信。如果是要子进程向父进程传输数据，同理即可。管道特点总结：
一个进程将同一个文件打开两次，一次以写方式打开，另一次以读方式打开。此时会创建两个struct file，而文件的属性会共用，不会额外创建如果此时又创建了子进程，子进程会继承父进程的文件描述符表，指向同一个文件，把父子进程都看到的文件，叫管道文件 管道只允许单向通信 管道里的内容不需要刷新到磁盘 2.2 创建匿名管道匿名管道：没有名字的文件(struct file)
匿名管道用于父子间通信，或者由一个父创建的兄弟进程（必须有“血缘“）之间进行通信
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#include <unistd.h>原型：int pipe(int fd[2]);功能:创建匿名管道参数 fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端返回值:成功返回0，失败返回错误代码</code>
使用如下：
代码语言：javascript代码运行次数：0运行复制<code class="javascript">int main(){ // 1. 创建管道 int fds[2] = {0}; int n = pipe(fds); // fds: 输出型参数 if(n != 0){ std::cerr << "pipe error" << std::endl; return 1; } std::cout << "fds[0]: " << fds[0] << std::endl; std::cout << "fds[1]: " << fds[1] << std::endl; return 0;}// 运行如下：island@VM-8-10-ubuntu:~/code$ ./codefds[0]: 3fds[1]: 4</code>注意：匿名管道需要在创建子进程之前创建，因为只有这样才能复制到管道的操作句柄，与具有亲缘关系的进程实现访问同一个管道通信
情况一：管道为空 && 管道正常（read 会阻塞【read 是一个系统调用】）具体代码演示如下：（子进程写入，父进程读取）
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#include <iostream>#include <unistd.h>#include <string.h>#include <sys/types.h>#include <sys/wait.h>#include <cstdlib>// 父进程 -- 读取// 子进程 -- 写入void write(std::string &info, int cnt){ info += std::to_string(getpid()); info += ", cnt: "; info += std::to_string(cnt); info += ')';}int main(){ // 1. 创建管道 int fds[2] = {0}; int n = pipe(fds); // fds: 输出型参数 if (n != 0) { std::cerr << "pipe error" << std::endl; return 1; } // 2. 创建子进程 pid_t id = fork(); if (id < 0) { std::cerr << "fork error" << std::endl; return 2; } else if (id == 0) { // 子进程 // 3. 关闭不需要的 fd, 关闭 read int cnt = 0; while (true) { close(fds[0]); std::string message = "(IsLand1314, pid: "; write(message, cnt); ::write(fds[1], message.c_str(), message.size()); cnt++; sleep(2); } exit(0); } else { // 父进程 // 3. 关闭不需要的 fd, 关闭 write close(fds[1]); char buffer[1024]; while(true) { ssize_t n = ::read(fds[0], buffer, 1024); if(n > 0) { buffer[n] = 0; std::cout << "child->father, message: " << buffer << std::endl; } } // 记录退出信息 pid_t rid = waitpid(id, nullptr, 0); std::cout << "father wait chile success" << rid << std::endl; } return 0;}</code>子进程每隔 2 s 向父进程写入数据，并且打印，如下：
从上面可以知道：
子进程写入的信息是变化的信息父进程打印信息的时间间隔和子进程一样，那么子进程没传入信息的时候，父进程处于阻塞 --> (IPC 本质：先让不同的进程，看到同一份资源，可以保护共享资源)情况二：管道为满 && 管道正常（write 会阻塞【write 是一个系统调用】）如下对代码做点修改（红框内的代码）
管道有上限，Ubuntu -> 64 KB
如果我们让父进程正常读取，那么结果又是怎样的呢？
运行如下：
当我们到 65536 个字节时，管道已满，父进程读取了管道数据，子进程会继续进行写入，然后进行继续读取，就有点数据溢出的感觉
情况三：管道写端关闭 && 读端继续（读端读到0，表示读到文件结尾）代码修改如下：
代码语言：javascript代码运行次数：0运行复制<code class="javascript">else if (id == 0){ int cnt = 0, total = 0; while (true) { close(fds[0]); std::string message = "h"; // fds[1] total += ::write(fds[1], message.c_str(), message.size()); cnt++; std::cout << "total: " << total << std::endl; // 最后写到 65536 个字节 sleep(2); break; // 写端关闭 } exit(0);}else{ // 父进程 // 3. 关闭不需要的 fd, 关闭 write close(fds[1]); char buffer[1024]; while (true) { sleep(1); ssize_t n = ::read(fds[0], buffer, 1024); if (n > 0) { buffer[n] = 0; std::cout << "child->father, message: " << buffer << std::endl; } else if (n == 0) { std::cout << "n: " << n << std::endl; std::cout << "child quit??? me too " << std::endl; break; } std::cout << std::endl; } pid_t rid = waitpid(id, nullptr, 0); std::cout << "father wait chile success" << rid << std::endl;}</code>运行如下：
结论：如果写端关闭，读端读完管道内部数据，再读取就会读取到返回值 0，表示对端关闭，也表示读到文件结尾
情况四：管道写端正常 && 读端关闭（OS 会直接杀掉写入进程）情况二：
如何杀死呢？
a. OS 会给 目标进程发送信号：13) SIGPIPE
b. 证明如下；
代码语言：javascript代码运行次数：0运行复制<code class="javascript">else if (id == 0){ int cnt = 0, total = 0; while (true) { close(fds[0]); std::string message = "h"; // fds[1] total += ::write(fds[1], message.c_str(), message.size()); cnt++; std::cout << "total: " << total << std::endl; // 最后写到 65536 个字节 sleep(2); } exit(0);}else{ close(fds[1]); char buffer[1024]; while (true) { sleep(1); ssize_t n = ::read(fds[0], buffer, 1024); if (n > 0) { buffer[n] = 0; std::cout << "child->father, message: " << buffer << std::endl; } else if (n == 0) { std::cout << "n: " << n << std::endl; std::cout << "child quit??? me too " << std::endl; break; } close(fds[0]); // 读端关闭 break; std::cout << std::endl; } // 记录退出信息 int status = 0; pid_t rid = waitpid(id, &status, 0); std::cout << "father wait chile success: " << rid << " exit code: " << ((status << 8) & 0xFF) << ", exit sig: " << (status & 0x7F) << std::endl;}</code>运行如下：
? 管道读写规则
家政服务平台系统包含家用电器安装清洗、搬家、家电维修、管道疏通、月嫂保姆、育儿陪护、上门开锁等多种服务项目，用户可以直接通过家政小程序咨询，在线预约服务类型，同时还设置有知识科普，给用户科普一些清洁保养小技巧，让用户能够足不出户就可以直接预约服务，方便又快捷。本项目使用微信小程序平台进行开发。使用腾讯专门的小程序云开发技术，云资源包含云函数，数据库，带宽，存储空间，定时器等，资源配额价格低廉，无需
0
进程池 -- 源码实现
后面我会写一篇博客专门来讲这个，敬请期待
4. 命名管道 ? 4.1 介绍匿名管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。命名管道是一种特殊类型的文件（命名管道 -- > mkfifo）4.2 创建命名管道Linux系统中，使用 mkfifo 命令创建有名管道文件，再使用两个进程打开即可代码语言：javascript代码运行次数：0运行复制<code class="javascript">$ mkfifo filename</code>
如上图，当我们在终端1创建了一个命名管道后，往里面写东西，管道不会关闭，在终端2上发现，它的内存大小还是0。
当我们在终端2打印出内容后，管道就自动关闭了。如下图：
<code class="javascript">int mkfifo(const char *pathname, mode_t mode);</code>
参数
pathname：要创建的命名管道的路径名。mode：创建命名管道时设置的权限模式，通常以 8 进制表示，比如 0666。返回值
若成功，返回值为 0；若失败，返回值为 -1，并设置errno来指示错误类型。功能
mkfifo() 函数的作用是在文件系统中创建一个特殊类型的文件，该文件在外观上类似于普通文件，但实际上是一个FIFO，用于进程之间的通信。这种通信方式是单向的，即数据写入FIFO的一端，可以从另一端读取出来，按照先进先出的顺序。? 案例：
代码语言：javascript代码运行次数：0运行复制<code class="javascript">std::string fifoPath = "/tmp/my_named_pipe"; // 命名管道的路径名mkfifo(fifoPath.c_str(), 0666); // 创建权限为0666的命名管道</code>
注意事项
路径名：确保要创建的命名管道路径名合法且没有重复。权限模式：根据实际需求设置合适的权限模式，确保可被需要访问该管道的进程所访问。错误处理：对 mkfifo() 函数的返回值进行适当的错误处理，根据具体的错误原因进行相应的处理和日志记录。4.3 命名管道通信案例先写如下的几个文件：
Comm.hpp
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#pragma once#include <iostream>#include <string>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>const std::string gpipeFile = "./fifo";const mode_t gmode = 0600;const int gdefultfd = -1;const int gsize = 1024;</code>
Client.hpp
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#pragma once#include <iostream>#include "Comm.hpp" // 让不同代码看到同一份资源class Client{public: Client():_fd(gdefultfd) {} bool OpenPipe() { _fd = ::open(gpipeFile.c_str(), O_WRONLY); if(_fd < 0) { std::cerr << "open error" << std::endl; return false; } return true; } // std::string *: 输出型参数 // const std::string &: 输入型参数 // std::string &: 输入输出型参数 int SendPipe(const std::string &in) { return ::write(_fd, in.c_str(), in.size()); } void ClosePipe() { if(_fd>=0) ::close(_fd); } ~Client() {}private: int _fd;};</code>Server.hpp
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#pragma once#include <iostream>#include "Comm.hpp"class Init{public: Init() { umask(0); int n = ::mkfifo(gpipeFile.c_str(), gmode); if (n < 0) { std::cerr << "mkfifo error" << std::endl; return; } std::cout << "mkfifo success" << std::endl; // sleep(10); } ~Init() { int n = ::unlink(gpipeFile.c_str()); if (n < 0) { std::cerr << "unlink error" << std::endl; return; } std::cout << "unlink success" << std::endl; }};Init init;class Server{public: Server(): _fd(gdefultfd) {} bool OpenPipe() { _fd = ::open(gpipeFile.c_str(), O_RDONLY); if(_fd < 0) { std::cerr << "open cerr" << std::endl; return false; } return true; } // std::string *: 输出型参数 // const std::string & : 输入型参数 // std::string &: 输入输出型参数 int RecvPipe(std::string *out) { char buffer[gsize]; ssize_t n = ::read(_fd, buffer, sizeof(buffer) - 1); if(n > 0) { buffer[n] = 0; *out = buffer; } return n; } void ClosePipe() { if(_fd>=0) ::close(_fd); } ~Server() {}private: int _fd;};</code>Client.cc(客户端，写入）
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#include "Client.hpp"#include <iostream>int main(){ Client client; client.OpenPipe(); std::string message; while(true) { std::cout << "Please Entere# "; std::getline(std::cin, message); client.SendPipe(message); } client.ClosePipe(); return 0; } </code>Server.cc（服务端，读取显示）
代码语言：javascript代码运行次数：0运行复制<code class="javascript">#include "Server.hpp"#include <iostream>int main(){ Server server; server.OpenPipe(); std::string message; while(true) { server.RecvPipe(&message); std::cout << "client Say# " << message << std::endl; } server.ClosePipe(); return 0; }</code>Makefile（通过 make 指令来生成可执行文件）
代码语言：javascript代码运行次数：0运行复制<code class="javascript">SERVER=serverCLIENT=clientCC=g++SERVER_SRC=Server.ccClient_SRC=Client.cc.PHONY:allall:$(SERVER) $(CLIENT)$(SERVER):$(SERVER_SRC)$(CC) -o $@ $^ -std=c++11$(CLIENT):$(Client_SRC)$(CC) -o $@ $^ -std=c++11.PHONY:cleanclean:rm -f $(SERVER) $(CLIENT)</code>
运行结果如下：
命名管道演示1
注意：如果客户端先退出，那么接收端就会进入死循环
命名管道演示 - 死循环
原因：
类似于我们上面说的匿名管道写端关闭，读端继续，读端读到0（文件结尾）死循环是因为 Server.hpp 文件只处理了 n > 0 的情况，因此我们需要做出一些修改，如下对 Server.cc文件做出的修改
运行结果如下：
命名管道-死循环解决演示
为了让我们代码更加优美，并且解决一些代码重复问题，我们再进行一步完善
代码语言：javascript代码运行次数：0运行复制<code class="javascript">// Comm.hpp#pragma once#include <iostream>#include <string>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>const std::string gpipeFile = "./fifo";const mode_t gmode = 0600;const int gdefultfd = -1;const int gsize = 1024;const int gForRead = O_RDONLY;const int gForWrite = O_WRONLY;int OpenPipe(int flag){ int fd = ::open(gpipeFile.c_str(), gForRead); if(fd < 0) { std::cerr << "open cerr" << std::endl; return false; } return fd;}void ClosePipeHelper(int fd){ if(fd>=0) ::close(fd);}// Client.hpp#pragma once#include <iostream>#include "Comm.hpp" // 让不同代码看到同一份资源class Client{public: Client():_fd(gdefultfd) {} bool OpenPipeForWrite() { _fd = OpenPipe(gForWrite); if(_fd < 0) return false; return true; } int SendPipe(const std::string &in) { return ::write(_fd, in.c_str(), in.size()); } void ClosePipe() { ClosePipeHelper(_fd); } ~Client() {}private: int _fd;};// Server.hpp#pragma once#include <iostream>#include "Comm.hpp"class Init{public: Init() { umask(0); int n = ::mkfifo(gpipeFile.c_str(), gmode); if (n < 0) { std::cerr << "mkfifo error" << std::endl; return; } std::cout << "mkfifo success" << std::endl; // sleep(10); } ~Init() { int n = ::unlink(gpipeFile.c_str()); if (n < 0) { std::cerr << "unlink error" << std::endl; return; } std::cout << "unlink success" << std::endl; }};Init init;class Server{public: Server(): _fd(gdefultfd) {} bool OpenPipeForRead() { _fd = OpenPipe(gForRead); if(_fd < 0) return false; return true; } int RecvPipe(std::string *out) { char buffer[gsize]; ssize_t n = ::read(_fd, buffer, sizeof(buffer) - 1); if(n > 0) { buffer[n] = 0; *out = buffer; } return n; } void ClosePipe() { ClosePipeHelper(_fd); } ~Server() {}private: int _fd;};</code>深入研究管道，继续对 Server.cc 文件进行修改，看看其第一次打开的时候在哪里阻塞
代码语言：javascript代码运行次数：0运行复制<code class="javascript">int main(){ Server server; std::cout << "pos 1" << std::endl; server.OpenPipeForRead(); std::cout << "pos 2" << std::endl; std::string message; while (true) { if (server.RecvPipe(&message) > 0) { std::cout << "client Say# " << message << std::endl; } else { break; } std::cout << "pos 3" << std::endl; } std::cout << "client quit, me too!" << std::endl; server.ClosePipe(); return 0;}</code>运行如下：
命名管道-阻塞演示
结论：
读端打开文件的时候，写端还没有打开，读端对用的 open 就会阻塞4.4 匿名管道与命名管道的区别? 匿名管道与命名管道的区别
匿名管道由 pipe函数 创建并打开。命名管道由 mkfifo函数 创建，打开用open。FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。4.5 命名管道的打开规则? 如果当前打开操作是为读而打开FIFO时
O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFOO_NONBLOCK enable：立刻返回成功? 如果当前打开操作是为写而打开FIFO时
O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFOO_NONBLOCK enable：立刻返回失败，错误码为ENXIO管道是一种用于进程间通信（IPC）的机制，允许一个进程将数据传递给另一个进程。在类Unix操作系统中，管道通常由内核提供，使用简单的读写接口。
管道分为两种类型：无名管道和命名管道
无名管道主要用于具有亲缘关系的进程（如父子进程），在创建时不需要名称，只能通过文件描述符进行访问命名管道（FIFO）则可以在任何进程之间通信，使用文件系统中的路径来标识管道的特点
管道是单向的：数据在一个方向上流动，从写端（写入数据的进程）到读端（读取数据的进程）在写端，数据会被写入一个缓冲区，读端则从这个缓冲区读取数据管道的缓冲区大小有限，因此如果写入的数据超过缓冲区容量，写入进程会被阻塞，直到有空间可用。管道的优点在于其简单性和高效性，适用于需要实时数据传输的场景。然而，由于其单向特性和有限的缓冲区，复杂的通信需求可能需要其他IPC机制，如消息队列或共享内存。总的来说，管道是一种基础而有效的进程间通信工具。
以上就是【Linux】IPC 进程间通信（一）：管道（匿名管道&命名管道）的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
649
