Linux： 进程间通信

目录

一 前言 

二 进程间通信目的

三 进程间通信方法

四 管道通信 

1. 进程如何通信

2.管道概念

2.1匿名管道 

2.2 匿名管道对多个进程的控制

2.3 命名管道

 2.4 命名管道原理

---

一 前言 

在我们学习进程的时候，我们知道正是因为程序地址空间的存在，所以进程之间具有独立性，他们互不影响，但是在我们的实际应用中，进程之间总会有需要通信（交流获取对方数据）。

---

二 进程间通信目的

• 数据传输：一个进程需要将它的数据发给另一个进程。

• 资源共享：多个进程之间共享同样的资源。

• 通知事件：一个进程需要向另一个进程或一组进程发送消息，通知它（它们）发生了某种事件。

• 进程控制：有些进程希望完全控制另一个进程的执行，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态的转变。比如我们在程序调试代码的时候就是一个进程完全控制了另一个进程。

---

三 进程间通信方法

Linux为用户提供了三种进程间通信的方法

• pipe管道通信：比如我们在进程一篇中用到的命令 ‘|’ 就是使用管道，该命令是和其他命令组合起来使用的。如搭配 grep 文本內容过滤工具使用。" ps -ajx | grep lrk "该命令就是将ps进程执行的数据通过管道传输给了 grep，才能筛选出指定的內容。管道一般是用于本地进程之间的数据传输。其又分为 匿名管道 和 命名管道
• POSIX进程通信：是一套进程通信的标准，可以为操作系统提供进程通信的接口。
• System V进程通信：也是一套进程通信的标准，可以为操作系统提供进程通信的接口。

---

四 管道通信 

1. 进程如何通信

 我们知道进程的程序地址空间决定了进程之间的独立性，这就给进程之间的通信造成了极大的困难，但是我们思考一下通信的本质是什么，即就是一个进程向另一个进程传递数据，而我们的进程始终是在操作系统内运行着的，那么进程是不是可以通过操作系统中的资源进行通信呢？

就像一个进程向同一份文件中写入数据，另一个进程去该文件中读取。这样的情况下，我们就通过访问同一个资源达成了数据传输的目的。即进程之间的通信的前提其实是不同的进程需要先能够看到、能够获取到同一份资源（文件、内存等）。该资源的种类其实就决定了进程通信的方式。

2.管道概念

管道是Unix中最古老的进程间通信的方式了。管道顾名思义，就是类比于生活中的管道才得名的。只不过生活中的管道输送的是谁、天然气等现实生活中的资源，而系统中的管道则是传输数据的，是一个进程链接到另一个进程的数据流。

事实上，管道就是一个被打开的文件（内存级文件），但是这个文件很特殊，向这个文件内写入的数据实际上并不会放入磁盘中，管道是在内存中实现的，并由操作系统的内核管理。当一个进程向管道写入数据时，这些数据被存储在内核中的缓冲区；然后，另一个进程可以从同一管道读取这些数据。一旦数据被读取，它们就从缓冲区中移除，符合现实中的管道特征：只传输资源，不存储资源。且需要注意的是管道是单项传输的。示意图 如下：

管道分为两种：匿名管道和命名管道 ，其实就是根据两种管道所打开的方式不同而做的分类。 

2.1匿名管道 

    匿名管道从名字来说，这个管道没有特定的名称，即在创建它的时候，不会指定打开文件的文件名、文件路径等，不会创建实际文件在文件系统中，纯粹存在于内存中，由操作系统内核进行管理。用于进程间通信。由于匿名管道是非明确目标的文件，对于两个毫不相关的进程是无法一起找到这个管道文件的（即两个无关的进程是无法找到公共资源），也就是说只有具有“血缘”关系的进程才能使用匿名管道进行通信。而父子进程共享数据，因此父子进程可以通过创建匿名管道进行通信。

💊下面就图解一下父子进程如何创建匿名管道进行通信

1.首先父进程分别以只读和只写打开管道文件（创建管道文件过程）：

2.接着父进程创建子进程，子进程会继承父进程的文件打开方式： 

3.接下来父进程关闭读端，子进程关闭它的写端，父进程只负责往管道文件里面写入，子进程读取就行了 

这样就创建了一个匿名管道。

🚀:为什么父进程需要以两种方式打开管道文件呢？不能以想要的方式打开管道文件然后子进程再以它想要的方式打开文件不就行了？这种太过于麻烦了，子进程在创建的时候会自动继承父进程的文件打开方式，这时候我们只需要各自关闭一个文件即可。

🎯匿名管道的创建

系统调用函数：pipe()

 int pipe(int pipefd[2]),中 pipefd[2],这个数据存放的是什么呢？我们接下来打印一下看看。

 运行结果：

1. pipe[0]=3：存储的是以只读方式打开管道时获取的fd
2. pipe[1]=4：存储的是以只写方式打开管道时获取的fd 

🏃接下来我们根据父子进程创建匿名管道进行通信的三个步骤写一个测试：

1.首先父进程分别以只读和只写打开管道文件（创建管道文件过程,通过系统调用函数pipe(）---------------------->2.接着父进程创建子进程，子进程会继承父进程的文件打开方式----------->3.接下来父进程关闭读端，子进程关闭它的写端，父进程只负责往管道文件里面写入，子进程读取就行了

#include <iostream>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
using namespace std;
//mypipe.cpp
//父进程进行读取，子进程进入写入
int main()
{// 第一步，创建管道文件，打开读写端int fds[2];int n = pipe(fds);assert(n == 0);// 第二步,创建一个子进程forkpid_t id=fork();assert(id>=0);if(id==0){//子进程进行写入close(fds[0]);//子进程通信代码const char* s="我是子进程，我正在给你发消息";int cnt=0;while(true){cnt++;char buffer[1024];//向指定缓冲区写入snprintf(buffer,sizeof buffer,"child->parent say: %s[%d][%d]\n",s,cnt,getpid());//子进程向管道写入端写入write(fds[1],buffer,strlen(buffer));//将buffer的数据写入管道sleep(5);//每隔1秒写入一次//sleep(50);}//写入完成结束之后，把子进程写入端关闭close(fds[0]);exit(0);}//父进程进行读取close(fds[1]);//父进程通信代码while(true){char buffer[1024];//cout<<"AAAAAAAAAAAAAAAAAAAAAAAAAA"<<endl;ssize_t s=read(fds[0],buffer,sizeof(buffer)-1);//将读取的数据放到buffer中，读取大小为sizeof(buffer)//cout<<"BBBBBBBBBBBBBBBBBBBBBBBBBB"<<endl;if(s>0) buffer[s]=0;cout<<"Get Message"<<buffer<<"| my pid "<<getpid()<<endl;//这样父进程就读到了子进程传输的信息。}//进程等待n=waitpid(id,nullptr,0);assert(n==id);//读取完成结束之后，把父进程读取端关闭close(fds[0]);return 0;
}

运行结果 

接下来我们对代码进行一点改动。来探索，子进程是依何种状态来与父进程进行通信的

 运行结果

从测试结果可知，当父进程sleep(50)之后向管道写入的时候，子进程会进入阻塞状态一直等待父进程向管道传输数据。

 ⛳pipe文件具有访问控制机制，必须先写入才能读取。父子进程在对管道文件进行读写操作是阻塞式I\O，即管道文件中必须先有数据，读取端才能去读取，否则调用read时就会发生阻塞；同样，如果管道中被写满了数据，此时再调用write也会发生阻塞，直到管道中有足够的空间来写入。

2.2 匿名管道对多个进程的控制

🍰上面我们看到了只由一个父进程通过管道文件派发任务控制一个子进程的例子，那我们当然也可以通过对多个子进程派发任务来控制多个子进程。此时一个匿名管道就不够用了，我们需要多个匿名管道，既然需要创建多个匿名管道，那么我们就需要让父进程知道不同的子进程对应的不同的管道的写端。即我们需要让父进程知道所要派发任务的子进程的匿名管道的写端。

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <cassert>
#include <vector>
#include <string>
#include <sys/wait.h>
#include <sys/types.h>
#include <ctime>#define PROCSS_NUM 5//子进程个数
#define MakeSeed() srand((unsigned long)time(nullptr) ^ getpid() ^ 0x124587 ^ rand() % 1234)//定义随机种子，用来随机选择进程///子进程要完成的任务///
typedef void (*func_t)(); // 函数指针，表示进程任务
void downLoadTask()
{std::cout <<getpid()<< ":下载任务" << std::endl;sleep(1);
}
void ioTask()
{std::cout <<getpid()<< ":IO任务" << std::endl;sleep(1);
}
void flushTask()
{std::cout << getpid()<<":刷新任务" << std::endl;sleep(1);
}
// 加载任务函数：将3个任务加载起来，放到vector中，组成加载任务表
void loadTaskFunc(std::vector<func_t> *out)
{assert(out);out->push_back(downLoadTask);out->push_back(ioTask);out->push_back(flushTask);
}/多进程程序/
// 子进程端点
class subEp
{
public:// 构造函数subEp(pid_t subId, int writeFd): subId_(subId), writeFd_(writeFd){char nameBuffer[1024];snprintf(nameBuffer, sizeof nameBuffer, "process-%d[pid(%d)-fd(%d)]", num++, subId, writeFd);name_ = nameBuffer;}public:static int num;std::string name_; // 子进程名称pid_t subId_;      // 子进程的pidint writeFd_;      // 子进程写端的文件描述符
};
int subEp::num = 0; // 静态变量初始化要在类外//读取父进程传递给子进程命令码：即读取管道的读端
int recvTask(int readFd)
{int code=0;ssize_t s=read(readFd,&code,sizeof(code));//读取到&code中，大小4个字节if(s==4) return code;//返回读取结果else if(s<=0) return  -1;else  return 0;
}
// 创建子进程
void createSubProcess(std::vector<subEp> *subs, std::vector<func_t> &funcMap)
{for (int i = 0; i < PROCSS_NUM; i++){// 为每个进程建立对应的管道int fds[2];int n = pipe(fds);assert(n == 0);(void)n;pid_t id = fork();if (id == 0){// 子进程,进行处理任务close(fds[1]); // 子进程进行读取while (true){// 1.获取命令码，如果没有发送，进程阻塞int commandCode=recvTask(fds[0]);//读取过程//父进程如果不写，子进程处于阻塞状态，父进程代码持续执行// 2.完成任务if(commandCode>=0 && commandCode < funcMap.size()) funcMap[commandCode]();//执行对应函数else if(commandCode==-1) break;}exit(0);}//父进程对于代码close(fds[0]); // 父进程关闭对应管道的读端进行写入subEp sub(id, fds[1]);subs->push_back(sub);//走到这里有5个子进程且有对于的pid 和writeFd}
}
// 发送任务
void sendTask(const subEp &process, int taskNum)
{std::cout << "send task num:" << taskNum << "send to-> " << process.name_ << std::endl;int n = write(process.writeFd_, &taskNum, sizeof taskNum);//父进程向子进程写入//write(fd,buffer,sizeof buffer)//将buffer的内容写入fd对应的文件//父进程向那个子进程的writeFd写入了，那个子进程开始读取assert(n == sizeof(int));(void)n;
}void loadBlanceControl(const std::vector<subEp>& subs,const std::vector<func_t> & funcMap, int count)
{// 2. 走到这就是父进程，控制子进程int processnum = subs.size();//子进程个数5个int tasknum = funcMap.size(); // 任务个数bool forever= (count==0 ? true :false);while (true){// 1.选择一个进程--------->std::vector<subEp>--->index------>随机数int subIdx = rand() % processnum; // 一共有多少子进程// 2. 选择一个任务-------->std::vector<func_t>---indexint taskIdx = rand() % tasknum;// 3. 任务发给选择的进程(父进程进行写)sendTask(subs[subIdx], taskIdx);//父进程向管道写入任务几的时候，此时子进程就不是阻塞状态了开始读取sleep(1);if(!forever){count--;if(count==0) break;}}//父进程退出，关闭各个子进程写端for(int i=0;i<processnum;i++) close(subs[i].writeFd_);
}
//回收子进程
void waitProcess(std::vector<subEp> process)
{int processnum=process.size();for(int i=0;i<processnum;i++){waitpid(process[i].subId_,nullptr,0);std::cout<<"wait subprocrss success ..."<<process[i].subId_<<std::endl;}
}int main()
{MakeSeed();//随机种子，用来随机分配任务// 1建立5个子进程并建立和子进程通信的匿名管道std::vector<func_t> funcMap; // 任务表loadTaskFunc(&funcMap);//将任务都放在vector中std::vector<subEp> subs;//子进程，subEp是一个类createSubProcess(&subs, funcMap);//创建子进程，且这个函数会给每个进程分配一个任务// 2. 走到这就是父进程，控制子进程int taskCnt=20;//0:永远进行loadBlanceControl(subs,funcMap,taskCnt);// 3.回收子进程信息。waitProcess(subs);return 0;
}

运行结果 

2.3 命名管道

🍉：上述管道应用的一个限制：就是只能在具有共同祖先（具有亲缘关系）的进程间通信。因父子进程共享资源，所以彼此能找到公共资源。 如果我们想在不相关的进程之间交换数据，该怎么做呢？

我们可以使用FIFO文件来做这项工作，它经常被称为命名管道。 命名管道是一种特殊类型的文件

创建命名管道函数mkfifo()

接下来我们写一个例子，来初步理解命名管道

然后我们用系统调用函数mkfifo()，创建一个命名管道 

上述-------------------done > named_pipe 向命名管道named_pipe  输入hello linux

>  命令行可以看成一个进程，向named_pipe  输入数据。   cat <  可以看出另外一个不相关的进程 ，通过cat < named_pipe 

     cat <named_pipe  输出了hello Linux   ，我们可以理解为完成了两个不相关的进程通过named_pipe完成了通信。

 2.4 命名管道原理

🌔：要想进行进程间的通信，必须让两个进程看到同一份资源，那命名管道是如何做到让两个不同的进程看到同一份资源的？

我们可以让不同的进程打开指定名称（路径+文件名）的同一文件

路径+文件名=唯一性

命名管道是操作系统提供的可以共享的资源，不同的是命名管道是一个特殊的文件，它与普通文件有所不同，命名管道文件的内容不需要刷新到磁盘中，因为它仅需要进行通信即可，不需要耗费时间空间去将内容保存在磁盘中，所以它的文件大小一直是0。 

接下来我们写一个测试，让不同的进程通过命名管道进行通信

#include"common.hpp"
//客户端   client.cpp
int main()
{int rfd=open(NAMED_PIPE,O_WRONLY);if(rfd<0)  exit(-1);//WRITEchar buffer[1024];while(true){std::cout<<"please say#"<<std::endl;fgets(buffer,sizeof(buffer),stdin);buffer[strlen(buffer)-1]=0;ssize_t n= write(rfd,buffer,strlen(buffer));}close(rfd);return 0;
}

#include "common.hpp"
//服务端 server.cpp
int main()
{//服务端，创建命名管道bool r =createFifo(NAMED_PIPE);assert(r);//通信int rfd=open(NAMED_PIPE,O_RDONLY);//打开文件，以读的方式if(rfd<0)  exit(-1);//readchar buffer[1024];while(true){ssize_t s= read(rfd,buffer,sizeof( buffer)-1);if(s>0){buffer[s]=0;std::cout<<"client->server :    "<<buffer<<std::endl;}else if(s==0){std::cout<<"client quit"<<std::endl;break;}else{std::cout<<"client error"<<std::endl;}}//移除管道close(rfd);removeFifo(NAMED_PIPE);return 0;
}

 server.cpp 和client.cpp通过 共同文件common.cpp进行通信。

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <string>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <unistd.h>
#include <fcntl.h>#define NAMED_PIPE "/tmp/mypipe.100"    //定义一个命名管道路径
common.cpp
bool createFifo(const std::string& path)
{umask(0);int n=mkfifo(path.c_str(),0600);if(n==0) return true;else{std::cout<<"errno:"<< errno <<"err string:"<< strerror(errno) <<std::endl;return false;}
}void removeFifo(const std::string &path)
{int n= unlink(path.c_str());assert(n==0);(void)n;
}

运行结果如下：

---