目录
进程通信的目的
管道
见见猪跑(举个例子)
文件描述符fd与管道的关系(深度理解管道)
什么是管道？
匿名管道
pipe函数概述
父子进程通信时与文件描述符的关系图(理解pipe函数的关键)
pipe函数的使用
管道读写规则
管道的大小
自测
使用man 7 pipe查看
使用ulimit -a查看
管道的特征
命名管道
概念
mkfifo函数
先举例说明
mkfifo函数
用命名管道实现serve与client通信
comm.hpp
client.cc
server.cc
进程通信的目的
数据传输：一个进程需要将它的数据发送给另一个进程。
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
我们可以使用多进程协同完成某种业务。
管道
见见猪跑(举个例子)
cat file.txt | grep "mwb" 将file.txt中包含mwb的一行信息给筛选出来了。
这里的' | '就是使用的匿名通信的方式将这两个进程建立了通信，' | '叫做管道。
文件描述符fd与管道的关系(深度理解管道)
进程通信的本质就是让两个进程看到同一份资源，因此在内存中就有这样一块区域(如上图所示)。
我们在冯诺依曼体系结构中已经学过，磁盘的IO速度相对于内存和CPU来说极低，因此我们在进行进程间通信的时候可以不用访问磁盘，在内存中就可以实现。
进程具有独立性，当我们使用上述区域就可以实现父子进程之间通信。
什么是管道？
管道是Unix中最古老的进程间通信的形式。
我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”
who程序运行成进程后，将数据输出到管道中，然后管道又将数据输入到wc进程中。
匿名管道
匿名管道可以让父子间进行进行通信。
pipe函数概述
函数原型
int pipe(int fd[2]);pipe函数里面的这个参数是一个输出型参数，也就是当我们使用pipe函数的时候，可以得到fd[0]和fd[1]。这两个分别被称为读端和写端，匿名管道如同在生活中的天然气管道。只能从天然气公司到你家，是单向的。
参数
fd[2]是一个文件描述符数组。
fd[0]为读端(为了便于记忆我们可以把0当做一个嘴巴)
fd[1]为写端(为了便于记忆我们可以把1当做一支笔)
返回值
成功返回0，失败返回错误代码。
单个进程中文件描述符与管道的关系
父子进程通信时与文件描述符的关系图(理解pipe函数的关键)
由于每个进城都有对应的写端和读端，当我们希望让父子进程进行通信的时候(比如让父进程写，子进程读)如上图。我们需要把父进程的读端和子进程的写端给关闭，以防被别人不小心的使用造成不必要的麻烦。
因此我们只需要让父子进程分别以读写方式打开同一个文件(本质就是看到同一块资源)。
pipe函数的使用
注意：代码中是子进程进行写入，父进程读取！
代码中有详细的解析！
#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/wait.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
// 父进程写，子进程读
// 父进程关闭读端(fd[0])，子进程关闭写端(fd[1])
int main()
{
// 定义一个fd的数组
int fd[2] = {0};
// 接受一下pipe的返回值进行断言判断
int a = pipe(fd);
assert(a == 0);
// fork创建子进程
pid_t id = fork();
// 以防创建失败，创建失败后面的代码就没有意义了
assert(id >= 0);
// 子进程
if (id == 0)
{
// 子进程关闭读端
close(fd[0]);
// 定义一个字符串用作管道中的内容
const char *msg = "### 你好父进程 ，我是子进程！###";
int count = 6;
while (count--)
{
cout << "count: " << count << endl;
// 将文件内容输入管道中
write(fd[1], msg, strlen(msg));
sleep(1);
}
// 子进程写入完毕关闭写端
close(fd[1]);
// 成功退出子进程
exit(0);
}
// 父进程
// 父进程关闭写端
close(fd[1]);
// 定义一个数组来接受读到的字符串
char buffer[1024];
// 死循环的读取(若读完管道的内容或者读取失败会在while函数体中进行break)
while (1)
{
// 使用read读出管道的内容读到buffer中
ssize_t s = read(fd[0], buffer, sizeof(buffer));
if (s > 0)
{
// buffer[s]='\n';
cout << "父进程收到了子进程的信息：" << buffer << endl;
}
// s==0已经读到了管道内容的结尾
else if (s == 0)
{
cout << "父进程已经读取完了！" << endl;
break;
}
else
{
cout << "读取错误！" << endl;
cout << "s: " << s << endl;
break;
}
// sleep(1);
}
// 父进程读取完毕，关闭写端
close(fd[0]);
// 定义一个status用来接受一下子进程的退出码
int status;
waitpid(id, &status, 0);
cout << "退出码：" << ((status >> 8) & 0xFF) << endl;
return 0;
}现象：
用fork来共享管道
管道读写规则
1、当管道里面没有数据的时候，会阻塞当前的读端的进程，直到管道里面有数据才会被唤醒。
2、当管道里面数据被写满时会阻塞当前的写入进程，直到管道里面的数据被读取后(管道有空间后)会唤醒写入进行。
3、如果写入进程关闭了写端，读进程会把管道里面的数据读完然后成功退出。
4、如果读进程关闭了读端，操作系统就会向写进程发送13号信号SIGPIPE来杀死写进程。
管道的大小
自测
我们可以使用父进程向管道里面不断的写入数据，以每次写入一字节进行计数。然后让子进程sleep起来，当管道写满后就会阻塞，此时计数的值就是管道的大小。
#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/wait.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
// 父进程写，子进程读
// 父进程关闭读端(fd[0])，子进程关闭写端(fd[1])
int main()
{
int fd[2] = {0};
int a = pipe(fd);
assert(a == 0);
// fork创建子进程
pid_t id = fork();
// 子进程
if (id == 0)
{
// 子进程关闭读端
close(fd[0]);
// close(fd[0]);
const char *msg = "a";
int count = 0;
while (1)
{
cout << "count: " << count << endl;
write(fd[1], msg, strlen(msg));
count++;
}
close(fd[1]);
exit(0);
}
// 父进程
close(fd[1]);
// close(fd[0]);
char buffer[1024];
while (1)
{
sleep(10000);
ssize_t s = read(fd[0], buffer, sizeof buffer);
if (s > 0)
{
// buffer[s]='\n';
cout << "父进程收到了子进程的信息：" << buffer << endl;
}
else if (s == 0)
{
cout << "父进程已经读取完了！" << endl;
break;
}
else
{
cout << "读取错误！" << endl;
cout << "s: " << s << endl;
break;
}
sleep(1);
}
// 父进程读取完毕
close(fd[0]);
int status;
waitpid(id, &status, 0);
cout << "退出码：" << ((status >> 8) & 0xFF) << endl;
return 0;
}
由运行结果可以发现，count的值阻塞在65536，因此当前管道的大小为65536byte。
使用man 7 pipe查看
man手册上面之处2.6.11后的版本是65536，那么我们查看一下我们的版本。
是2.6.11后的版本，因此是65536。
使用ulimit -a查看
通过ulimit -a查看到 pipe size 一次原子写入为：512Bytes*8=4096Bytes
查看缓冲条目个数：cat /usr/src/kernels/内核版本/include/linux/pipe_fs_i.h文件
所以我的pc下得pipe缓冲大小为：16*4096=65536Bytes
也就验证了man 7 pipe下的pipe capacity。
管道的特征
1、管道的生命周期随进程。
2、管道可以用来进行具有血缘关系的进程之间进行通信，常用于父子通信。
3、管道是面向字节流的(网络)。
4、半双工——单向通信(特殊概念)。
5、同步于互斥机制 —— 对共享资源进行保护的方案。
命名管道
概念
- 管道应用的一个限制就是只能在具有共同祖先(具有亲缘关系)的进程间通信。
- 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。
- 命名管道是一种特殊类型的文件。
mkfifo函数
先举例说明
使用mkfifo创建一个命名管道
当我们向管道里面写入数据的时候，但是反复去查看named_pipe的大小的时候，发现大小一直为0，并没改变，这也印证了我们之前说的管道并不在磁盘这一观点。
下列gif图中我们左边向管道中进行不断的重定向一些数据，然后右边使用cat可以读取到我们管道中的数据。
并且需要我们注意的是，当我们Ctrl+C中断当前正在运行的程序或命令时，左边直接就退出了，也印证了之前我们说的当把读进程的读端给关闭的时候，写进程就会被杀死！
mkfifo函数
首先通过man手册去查看mkfifo函数。
第二个参数是权限。
用命名管道实现serve与client通信
comm.hpp
#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define NAMED_PIPE "/tmp/mypipe"
//创建管道文件函数
bool createFifo(const std::string& path)
{
umask(0);
// 创建管道文件
int n=mkfifo(path.c_str(),0600);
if(n==0)
return true;
else
{
std::cout<<"error:"<<errno<<"error string"<<strerror(errno)<<std::endl;
return false;
}
}
//销毁管道
void destroyFifo(const std::string& path)
{
int n=unlink(NAMED_PIPE);
assert(n==0);
(void)n;
}client.cc
#include "comm.hpp"
int main()
{
// 客户端以只写的方式打开文件
int wfd = open(NAMED_PIPE, O_WRONLY);
if (wfd == -1) // 打开失败
{
exit(1);
}
char buffer[1024];
while (true)
{
std::cout << "you can say:";
//这里使用fgets来获得我们从键盘中输入的字符串
fgets(buffer, sizeof(buffer), stdin); // fgets剩一个空间会被系统填充'\0',不用-1
ssize_t s = write(wfd, buffer, strlen(buffer));
assert(s == strlen(buffer));
(void)s;
}
close(wfd);
return 0;
}server.cc
#include "comm.hpp"
int main()
{
// 创建一个文件
bool c=createFifo(NAMED_PIPE);
// assert(c);
// // 以免c没被用到而报错
// (void)c;
std::cout << "server begin" << std::endl;
//会等用户端打开管道文件，服务端才进行open服务端以只读的方式打开
int rfd =open(NAMED_PIPE,O_RDONLY);
//打开失败
if(rfd==-1)
{
//异常退出
exit(1);
}
//读取
char buffer[1024];
while(true)
{
ssize_t s=read(rfd,buffer,sizeof(buffer)-1);
if(s>0)
{
buffer[s]=0;//将最后一个字符设置为'\0'
std::cout<<"client->server:"<<buffer;
}
// 说明服务端一直没有接收到数据
else if(s==0)
{
std::cout << "client quit, me too!" << std::endl;
break;
}
else//读取出错
{
std::cout<<"err string"<<strerror(errno)<<std::endl;
break;
}
}
close(rfd);
destroyFifo(NAMED_PIPE);
return 0;
}gif动图演示：
comm.hpp
对于如何让客户端和服务端使用同一个命名管道文件，这里我们可以让客户端和服务端包含同一个头文件，该头文件当中提供这个共用的命名管道文件的文件名，这样客户端和服务端就可以通过这个文件名，打开同一个命名管道文件，进而进行通信了。
步骤：
1、首先让服务端运行起来，让服务端创建一个文件。然后再以读的方式去打开这个文件。
2、对于客户端来说，服务端已经把文件创建完毕，客户端只需要以写的方式打开文件，将通信信息写入文件就行。文章来源：https://www.toymoban.com/news/detail-435526.html
3、当我们在最后ctrl c关闭客户端的时候，此时服务端检查到管道文件中没数据可读的时候就也关闭了。文章来源地址https://www.toymoban.com/news/detail-435526.html
到了这里，关于Linux——进程间通信(管道)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![[Linux]进程间通信--管道](https://imgs.yssmx.com/Uploads/2024/02/708894-1.gif)
