一、进程间通信介绍

1.1、进程间通信的概念和意义

进程间通信(IPC interprocess communication)是一组编程接口，让不同进程之间相互传递、交换信息(让不同的进程看到同一份资源)

数据传输:一个进程需要将它的数据发送给另外一个进程

资源共享:多个进程之间共享同样的资源

通知事件:一个进程向另一个或一组发送消息

进程控制:有些进程希望完全控制另一个进程的执行

为什么要进行进程间通信？

以上的行为往往需要多个进程协同、共同完成一些事情

两个进程之间是不能进行”数据”的直接传递的(进程具有独立性)

不要以为，进程独立了就是彻底独立，有时我们需要双方能够进行一定程序的信息交互。

1.2、如何进行进程间通讯及其本质

怎么办？

一般规律

1、交换数据的空间(内存)

2、不能由通信双方任何一个提供(那由谁提供，OS提供) 

具体做法

OS提供的"空间"有不同的样式，就决定了有不同的通信方式

1、管道(匿名、命名)

2、共享内存

3、消息队列
4、信号量

进程间通信的本质：让不同的进程看到同一份资源(一般由OS提供)

为了进程在通信的时候，既能满足进程之间的独立性，又能够到达通信的目的，那么进程之间通信的地点就不能在两个进程中。 一个进程将自己的数据交给另一个进程，并且还要等待另一个进程的应答，这样一来，这个进程将不独立了，受到了另一个进程的影响，这就与进程的独立性矛盾。所以，两个进程进行通信的地点必须是由第三方提供的，第三方只能是操作系统。操作系统提供的这个地点被我们称为：公共资源。公共资源有了，还必须让要通信的进程都看到这一份公共资源，此时要通信的进程将有了通信的前提。之后就是进程通信，也就是访问这块公共资源的数据。

之所以有不同的通信方式，是因为公共资源的种类不一，如果公共资源是一块内存，那么通信方式就叫做共享内存，如果公共资源是一个文件，也就是struct file结构体，那么就叫做管道。

二、管道 

2.1管道介绍

什么是管道？

open("log.txt",w);
open("log.txt",r);

一个文件打开两次，那么在操作系统中会有2个struct file 但是这两个struct file指向同一个缓冲区 

 若父进程3为读端，4为写端，子进程也一样。那么子进程写入，父进程读取缓冲区内容，这是父子进程看到了同一块资源。

这种基于文件的，让不同进程看到同一份资源的通信方式叫做管道

管道只能被设计成单向通信 

如：子进程为写(writer，关掉读端)                                                父进程为读(reader，关掉写端)    当子进程关掉读端/父进程关掉写端对应的struct file没有释放掉，说明 struct file有引用计数(记录多少指针指向我) 当引用计数为0才释放。struct file是允许多个进程通过指针指向的。

为什么父进程最开始用rw方式打开同一个文件呢？                                                                            如果只以r方式打开的话，子进程拷贝完后就也是r；父进程只以w打开，子进程拷贝完也只是w

3.2匿名管道

匿名管道：就是没有名字的文件

如何让不同的进程看到同一份资源？匿名管道的解决办法是：创建子进程，继承父进程的属性信息，也就是说匿名管道可以(只能)进行具有血缘关系的进程进行进程间通信(常用于父子)

为了支持我们进行管道通信，OS提供系统调用pipe()

原型：int pipe(int fd[2]);

头文件unistd.h
功能:创建一无名管道
参数          fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码 

3.3匿名管道代码

通过系统调用接口创建一个匿名管道

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>using namespace std;int main()
{int pipefd[2];int ret = pipe(pipefd); // 一.创建管道if(ret < 0){cerr << errno << ": " << strerror(errno) << endl;}cout << "pipefd[0]: " << pipefd[0] << endl; // 3cout << "pipefd[1]: " << pipefd[1] << endl; // 4return 0;
}

然后就可以创建子进程，关闭不需要的读端或写端

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>using namespace std;int main()
{int pipefd[2];int ret = pipe(pipefd); // 一.创建管道if(ret < 0){cerr << errno << ": " << strerror(errno) << endl;}pid_t id = fork(); // 二.创建子进程assert(id != -1);if(id == 0){//子进程  关掉读端，只写close(pipefd[0]);exit(1);}//父进程//关掉写端，只读close(pipefd[1]);close(pipefd[0]); // 父进程，只写，关闭读return 0;
}

这时父子进程已经可以看到同一份资源，可以开始通信了

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<assert.h>void writer(int wfd)
{const char* str = "我是子进程,o.O,我在给你发消息";char buffer[128];int cnt = 0;pid_t pid = getpid();while(1){snprintf(buffer,sizeof(buffer),"message:%s,pid:%d,count:%d\n",str,pid,cnt);write(wfd, buffer, strlen(buffer));cnt++;sleep(1);}close(wfd);
}void reader(int rfd)
{char buffer[1024];int cnt = 10;while(1){size_t n = read(rfd,buffer,sizeof(buffer)-1);if(n>0)printf("父亲获得信息是: %s\n", buffer);else{printf("缓冲区读完了，文件也读完了\n");break;}cnt--;if(cnt==0)break;}close(rfd);
}int main()
{//创建管道int pipefd[2];int n = pipe(pipefd);if(n<0)return 1;pid_t id = fork();if(id == 0){//子进程  关掉读端，只写close(pipefd[0]);writer(pipefd[1]);exit(1);}//父进程//关掉写端，只读close(pipefd[1]);reader(pipefd[0]);int status = 0;pid_t rid = waitpid(id, &status, 0);if(rid == id)printf("退出码为:%d,信号为:%d\n",WEXITSTATUS(status), status & 0x7f);return 0;
}

匿名管道的一些读写现象以及对应的特性

按上面代码将子进程休眠上5s，那么在子进程休眠这段时间，父进程在等待子进程退出休眠(可以理解为管道内无数据)

写端一直写，读端一直不读或者很久读一次：若一次写入一个字符"A"，每次写入时cnt++，执行后会发现当cnt=65536时不在写入(也就是写入65536个字节时)65536÷1024=64

在Ubuntu20.04操作系统下默认建立的管道大小为64KB；

管道内部被写满，父进程还没有读取的时候，那子进程要等到父进程来读它

对以上两种情况的总结：

1.管道内部没有数据且子进程不关闭自己的写端文件fd，读端就要阻塞等待直到pipe有数据

2.管道内部被写满且读端不关闭自己的fd，写端写满后就要阻塞等待

由此推断出管道的两种特性：

特性一：自带同步机制

特性二：血缘关系进程进行通信，常见父子

若把父进程休眠时间改短一点，每次父进程读完后，子进程又能继续写入，在此过程中我们不难发现：无论写端写多少个，读端都能一次读完，由此我们发现管道的另一个特性：

特性三：管道是面向字节流的(写多少次和读多少次没有直接关系，称为面向字节流)

当子进程写入10s后退出，而父进程一直读，且打印了返回值，10s后子进程关掉写文件描述符，此时返回值为0；若父进程退出，子进程会僵尸 

3.对于写端而言，不写且关闭pipe，读端会将管道中的数据读完，返回值为0，表示读结束，类是读到了文件的结尾

若写端一直在写，而读端读一会就结束，关闭读文件描述符

4.读端不读且关闭，写端在写，OS会直接终止写入的进程(通过信号13SIGPIPE杀死进程)

由此可以得出管道另外的特性

特性四：父子进程退出，管道自动释放，文件的生命周期是随进程的

特性五：管道只能单向通信，半双工的一种特殊情况(一方传信息时，另一方不能传，如：对讲机)

 5.当要写入的数据量不大于PIPE_BUF(4KB)时，linux将保证写入的原子性。
6.当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

就是写入数据小于4kb，则次操作为安全的 

有时候公共资源有可能被两个执行流共同访问，访问时会出现信息交叉、数据混乱等问题；由此我们要有一种特性：一段数据、一块空间或一种资源我们要么不访问、要访问就把它改完了，这种特性叫原子性。

3.3进程池

processpool.cc

#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>
#include <unistd.h>
#include <ctime>
#include "task.hpp"using namespace std;enum
{UsageError= 1,ArgError,PipeError
};
void Usage(const std::string &proc)
{cout<<"Usage:"<<proc<<"sub_process_num"<<endl;
}
//用一个类封装管道
class Channel
{
public:Channel(int wfd,pid_t sub_id,const std::string &name)//构造:_wfd(wfd),_sub_process_id(sub_id),_name(name){}void PrintDebug(){cout << "_wfd: " << _wfd;cout << ",_sub_process_id: " << _sub_process_id;cout << ", _name: " << _name << endl;}string name() {return _name;}int wfd() {return _wfd;}pid_t pid() { return _sub_process_id; }~Channel()//析构{}private:int _wfd;//父进程通过此向channel写东西pid_t _sub_process_id;//记录子进程string _name;//channel名字
};//将冗长的创建子进程封装一下
class ProcessPool
{
public:ProcessPool(int sub_process_num) //构造: _sub_process_num(sub_process_num){}int CreateProcess(work_t work) // 回调函数{for (int number = 0; number < _sub_process_num; number++){int pipefd[2]{0};int n = pipe(pipefd);if (n < 0)return PipeError;pid_t id = fork();if (id == 0){// child -> rclose(pipefd[1]);// 执行任务dup2(pipefd[0], 0);work();exit(0);}string cname = "channel-" + to_string(number);// fatherclose(pipefd[0]);channels.push_back(Channel(pipefd[1], id, cname));}return 0;}int NextChannel(){static int next = 0;int c = next;next++;next %= channels.size();return c;}void SendTaskCode(int index, uint32_t code){cout << "send code: " << code << " to " << channels[index].name() << " sub prorcess id: " <<  channels[index].pid() << endl;write(channels[index].wfd(), &code, sizeof(code));}void Debug(){for (auto &channel : channels){channel.PrintDebug();}}~ProcessPool(){}private:int _sub_process_num;vector<Channel> channels;
};int main(int argc ,char* argv[])
{if(argc!=2){Usage(argv[0]);return UsageError;}int sub_process_num = std::stoi(argv[1]);//把进程数转整型if(sub_process_num == 0)return ArgError;//vector<Channel> channels;//把所有的channel(管道)push到vector中，那么对管道的管理就会变成对vector的增删查改//create process// for(int num=0;num<sub_process_num;num++)// {//     int pipefd[2]{0};//     int n = pipe(pipefd);//     if(n<0)//         return PipeError;//     pid_t id = fork();//     if(id == 0)//子进程//     {//         close(pipefd[1]);//         sleep(1);//         exit(0);//     }//     string cname = "channel-"+to_string(num);//     //父进程//     close(pipefd[0]);//     channels.push_back(Channel(pipefd[1],id,cname));// }ProcessPool *proc_ptr = new ProcessPool(sub_process_num);proc_ptr->CreateProcess(worker);//控制子进程// for(auto& e:channels)// {//     e.PrintDebug();// }while(1){// a. 选择一个进程和通道int channel = proc_ptr->NextChannel();// cout << channel.name() << endl;// b. 你要选择一个任务uint32_t code = NextTask();// c. 发送任务proc_ptr->SendTaskCode(channel, code);sleep(1);}//回收、等待子进程delete proc_ptr;return 0;
}

task.hpp

#include <iostream>
#include <unistd.h>using namespace std;typedef void(*work_t)();  //函数指针类型
typedef void(*task_t)();  //函数指针类型void PrintLog()
{cout << "printf log task" << endl;
}void ReloadConf()
{cout << "reload conf task" << endl;
}void ConnectMysql()
{cout << "connect mysql task" << endl;
}task_t tasks[3] = {PrintLog, ReloadConf, ConnectMysql};uint32_t NextTask()
{return rand() % 3;
}void worker()
{// 从0中读取任务即可！while(true){uint32_t command_code = 0;ssize_t n = read(0, &command_code, sizeof(command_code));if(n == sizeof(command_code)){if(command_code >= 3) continue;tasks[command_code]();}cout << "I am worker: " << getpid() << endl;sleep(1);}
}

makefile

processpool:processpool.ccg++ -o $@ $^ -std=c++11 -g
.PHONY:clean
clean:rm -f processpool

三、命名管道

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

man mkfifo：

指令：mkfifo 文件名

功能：创建命名管道文件

命名管道可以从命令行上创建，命令行方法是使用下面这个命令

mkfifo filename

此时就成功地建立了一个命名管道，可以发现它的（文件类型）权限前面的字母是p（pipe），而目录的文件类型是d（directory）。命名管道文件类型是p，而且该文件还有inode，说明在磁盘上是真实存在的。 

 当磁盘中有了命名管道文件以后，两个进程将可以通过这个管道文件进行通信了，步骤和匿名管道非常相似。一个进程以写方式打开管道文件，另一个进程以读端方式打开管道文件。

直接写入的话可以发现会阻塞在这里

它需要被另一个进程读取 

 可以通过unlink或者rm删掉命名管道

系统调用mkfifo以及unlink

第一个形参：管道文件的名字

第二个形参：创建管道文件的权限

返回值：0表示创建成功，-1表示创建失败。

man 2 unlink