目录
管道
pipe创建一个管道
让子进程写入，父进程读取
如何把消息发送/写入给父进程
父进程该怎么读取呢
管道本质
结论：管道的特征：
测试管道大小
写端退了，测试结果
测试子进程一直写，父进程读一会就退出
管道到的应用场景
写一个进程池(pipe_use)
思路步骤
管道创建
创建父子进程
父进程写，子进程读
子进程pid有了管道也有了，就差在父进程添加字段了
先更改一下，在class里构造一下
添加字段
把初始化改造成函数
debug测试函数，纯输入函数
第二步开始控制进程了（想让子进程做什么）
改变一下，直接从键盘（0号描述符）里读，不从管道（3）里读了，就没有管道的概念了，slaver就不用传参了，父进程通过管道写，子进程通过标准输入读
现在开始选择任务和进程
也可以轮询选择，定义一个计数器，++弄，再%等
清理收尾
bug的地方：
编辑
以上是匿名管道
总文件总代码
makefile中代码
Task.hpp中代码
ProcessPool.cc中代码
管道
首先自己要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区里面），然后用户层缓冲区通过系统调用（write）写到管道里，然后再通过read系统调用，被对方（读端）读取，就要从管道拷贝到读端，然后再显示到显示器上。
pipe创建一个管道
pipe的介绍
1完成这件事：
看图分析
运行结果
#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{//创建管道//先创建一个pipefd数组int pipefd[2];//用n接受一下，判断是否成功int n = pipe(pipefd);if(n<0) return 1;//创建失败了//创建成功//测试一下文件描述符是3和4cout<<"pipefd[0]:"<<pipefd[0]<<"pipefd[1]:"<<pipefd[1]<<endl;return 0;
}2完成这件事：
创建一个子进程
pid_t id = fork();if(id < 0)return 2;//创建失败if(id == 0)//创建成功{//子进程}//父进程让子进程写入，父进程读取
要想让子进程进程写，就需要在进程中关闭读端
if(id == 0)//创建成功
{//子进程close(pipefd[0]);
}同理
//父进程
close(pipefd[1]);都用完结束后，可以都关掉
if(id == 0)//创建成功{//子进程close(pipefd[0]);//.....close(pipefd[1]);}//父进程close(pipefd[1]);//.....close(pipefd[0]);IPC code，写通信代码
3这件事也完成了：
结构就有了
然后在pipefd[1]这个管道里写，定义一个Writer函数
if(id == 0)//创建成功{//子进程close(pipefd[0]);//.....IPC code，写通信代码//在pipefd[1]这个管道里写Writer(pipefd[1]);close(pipefd[1]);exit(0);//正常退出}同理父进程的
//父进程close(pipefd[1]);//.....IPC code，写通信代码//在pipefd[0]这个管道里写Reader(pipefd[0]);close(pipefd[0]);
//子进程
void Writer(int wfd)
{}
//父进程
void Reader(int rfd)
{}Writer
//子进程
void Writer(int wfd)
{string s = "hello,I am child";pid_t self = getpid();int number = 0;char buffer[10];while(true){buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了}
}用到snprintf
介绍
将s和self和number放进buffer
char buffer[100];while(true){buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了snprintf(buffer,sizeof(buffer),"%s pid:%d\n",s.c_str(),self);cout<< buffer <<endl;sleep(1);};用cout打印测试一下，打印成功说明写入buffer成功了
等待进程少不了，子进程exit后需要回收
//父进程close(pipefd[1]);//.....IPC code，写通信代码//在pipefd[0]这个管道里写Reader(pipefd[0]);//等待进程缺少不了pid_t rid = waitpid(id,nullptr,0);if(rid < 0) return 3;//等待失败了close(pipefd[0]);如何把消息发送/写入给父进程
用到了write
用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道
//子进程
void Writer(int wfd)
{string s = "hello,I am child";pid_t self = getpid();int number = 0;char buffer[100];while(true){buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了snprintf(buffer,sizeof(buffer),"%s pid:%d %d\n",s.c_str(),self,number++);//用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道write(wfd,buffer,strlen(buffer));//cout<< buffer <<endl;sleep(1);};
}父进程该怎么读取呢
用到了read，fd是文件描述符，从特定的文件描述符里读取，放在这个buf里，buf的长度是count
这里就需要考虑到\0，因为buffer中需要\0
//父进程
void Reader(int rfd)
{char buffer[100];while(true){buffer[0] = 0;//用sizeof是为了留个空间放\0ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlenif(n > 0){//添加\0，因为要放在buffer数组中读取buffer[n]=0;cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;}}
}运行结果
也会发现：为什么子进程sleep，父进程不sleep，父进程还是会跟着子进程sleep，因为父子进程是要协同的
管道本质
通信是为了更好的发送变化的数据，管道本质上是文件
所以必须要用到系统调用接口来访问管道，其是由系统管理，read和write
，操作系统相当于中介
结论：管道的特征：
1：具有血缘关系的进程进行进程间通信
2：管道只能单向通信
3：父子进程是会进程协同的，同步与互斥的--保护管道文件的数据安全
4：管道是面向字节流的
5：管道是基于文件的，而文件的生命周期是随进程的
再测试，把子进程sleep去掉，就是让子进程写快一点，父进程sleep几秒，就是让父进程读慢一点，看有什么现象
管道的四种情况
测试管道大小
把c一直往管道里写，把父进程中休眠50秒
结果差不多64kb
写端退了，测试结果
结果是：
读端正常读，写端关闭，读端就会读到0，表明读到了文件（pipe）结尾，不会被阻塞
read读取成功会返回读到的字符个数，读到结尾返回0
读到结尾父进程也就可以停止读取了，break后去把僵尸的子进程回收
break到这里
最后子进程会被waitpid回收
测试子进程一直写，父进程读一会就退出
定义一个cnt控制退出的时间
这里也要修改一下，加个sleep(5),观察，close提前关闭
结果：通过13号信号杀死
管道到的应用场景
都会变成一个进程
写一个进程池(pipe_use)
首先创建好文件
创建5个进程
channel通道的意思
cmdfd文件描述符
slaverid代表哪个子进程
把它放进vector容器里
思路步骤
管道创建
void（n），假装使用一下，要不然编译不过
创建父子进程
父进程写，子进程读
子进程要读取，就要关闭自己的写端，父进程同理
子进程中的任务
子进程pid有了管道也有了，就差在父进程添加字段了
先更改一下，在class里构造一下
添加字段
测试一下：结果：文件描述符0，1，2是默认打开，3是从管道里读，4是写入管道
把初始化改造成函数
debug测试函数，纯输入函数
第二步开始控制进程了（想让子进程做什么）
这里打印的rfd都是3，正常吗，文件描述符是可以被子进程继承的
父进程对应的写端拿到的是4-8，子进程拿到的读端fd是3
改变一下，直接从键盘（0号描述符）里读，不从管道（3）里读了，就没有管道的概念了，slaver就不用传参了，父进程通过管道写，子进程通过标准输入读
用到了dup2，将从pipefd[0]中读变成从0开始读
想让父进程固定的向管道里写入指定大小字节的内容，必须读取四个字节，四个字节四个字节的写和读，这里的管道64kb
必须读取四个字节
如果父进程不给子进程发送数据呢？阻塞等待!
开始控制子进程
生成一个随机数种子
可以随机选择任务和选择进程
cmd是任务码，测试一下，父进程控制子进程,父进程发送给子进程（通过cmdcode连续）
在Task.hpp里
要用到函数指针
main中的任务了就属于
再把任务装载进来
输出型参数用*
现在开始选择任务和进程
再把main中的任务弄成全局的
进行判断一下
测试 ,comcode和任创建的任务一致
这里的write是父进程进行写入，向子进程发送，子进程不得闲，先写到管道里，等得闲了再读
也可以轮询选择，定义一个计数器，++弄，再%等
整理一下控制代码，这里是输入型参数，只需要读
这样就可以轮询方式选择进程了，不用随机了
结果
清理收尾
思路：把所有文件的描述符都关掉
等待方式设置为0
read返回0，就是失败了，然后slaver就会调完
结束完就会exit直接退出
打印下更好显示
关闭文件描述符后sleep(10)秒，
然后这10个子进程一瞬间都应该break，然后最后到exit直接就退了，10秒结束后，父进程再回收他
测试时不弄死循环，用cnt，5秒后自动结束控制，正常退出流程
测试结果
手动控制一下
定义一个select，输入0就是退出了，判断完后，就走到了选择任务
然后直接把cmdcode改为选择的select，-1是因为是从下标0开始的，输入1就是0下标的
测试
bug的地方：
这样会有一些bug（一个子进程不是只有一个写端（每一次子进程的创建都是有继承））
这样会有一些bug（一个子进程不是只有一个写端（每一次子进程的创建都是有继承））
按理说这样是对的，可是这样就错了
因为下面两个红线还没有关掉，它们进程了最开始的w
这样倒着回收是可以的
正确改法
修改一下
最后一个push_back的就都是父进程的写入fd，
然后加一句这个红线的，每创建子进程后都先把上一次父进程的读端fd关掉就可以了，这里很妙，因为vector一开始是空的
方便看
这里这样就可以了
管道已经完成
以上是匿名管道
总文件总代码
makefile中代码
ProcessPool:ProcessPool.ccg++ -o $@ $^ -std=c++11
.PHNOY:clean
clean:rm -f ProcessPoolTask.hpp中代码
#pragma once#include<iostream>
#include<vector>using namespace std;typedef void (*task_t)();void task1()
{cout<< "lol 刷新日志" <<endl;
}void task2()
{cout<< "lol 更新野区" <<endl;
}void task3()
{cout<< "lol 检测软件更新" <<endl;
}void task4()
{cout<< "lol 释放技能" <<endl;
}
ProcessPool.cc中代码
注意：
这里为啥是取地址一个comcode，不是一个0吗，要发送的数据就是这个，所以要把地址传给函数，可以是个数组
换成数组的话，read这也接收数据的时候，就得用数组去接受，要是写入超过int大小的话，就可能会出错，这个就是通信的双方要遵守的约定，这个判断一下，就是派发的这个任务是不是合法的，假设你的tasks任务中，只有4个任务，所以任务编号就是0 ~ 3，如果你接受到的任务编号是10或者-20，那么这些就是非法的，你执行的话，程序就会崩溃，所以要做一个简单的判断。
write以后，cmdcode的值也会跟着传到read对吧，write就是为了把cmdcode的值传递给给另外一个进程，以前见到的都是用的char buffer[]；，这样&cmdcode能更方便的传值过去是不，看要传的是什么数据，只是传递一个int数据的话，就这样传递，如果是文本数据，或者是其他的话，可能就需要数组了，具体问题，具体讨论
#include "Task.hpp"
#include<iostream>
#include<string>
#include<vector>
#include<unistd.h>
#include<assert.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;//打算创建5个进程
const int processnum = 5;
//全局任务
vector<task_t> tasks;//先描述
class channel//管道
{
public:channel(int cmdfd,pid_t slaverid,string& processname):_cmdfd(cmdfd),_slaverid(slaverid),_processname(processname){}public:int _cmdfd;//文件描述符pid_t _slaverid;//代表哪个子进程string _processname;//子进程的名字,方便打印日志
};//子进程中读的任务
// void slaver(int rfd)
// {
// while(true)
// {
// cout<< getpid() <<" - "<< "read fd is->"<<rfd<<endl;
// sleep(1000);
// }
// }
//改变一下从fd为0的地方开始读
void slaver()
{//read(0);while(true){int cmdcode = 0;int n = read(0, &cmdcode, sizeof(int));if(n == sizeof(int)){//执行cmdcode对应的任务列表cout<< "slaver say@ get a command:" << getpid() << ":cmdcode:" << cmdcode <<endl;//判断一下并执行if(cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();}if(n == 0) break;}
}//初始化
void Init(vector<channel>& channels)
{for(int i =0;i < processnum;i++){int pipefd[2];int n = pipe(pipefd);//创建管道//返回值小于0就创建失败了assert(!n);(void)n;pid_t id = fork();if(id == 0){//子进程：读close(pipefd[1]);//改变一下从fd为0的地方读dup2(pipefd[0],0);close(pipefd[0]);//任务slaver();cout<< "process: " << getpid() << "quit" <<endl;//slaver(pipefd[0]);exit(0);}//父进程：写close(pipefd[0]);//channel添加字段string name = "processs-" + to_string(i);//插入的是自定义类型，要构造一下，第一个传的是文件描述符，要写入的fdchannels.push_back(channel(pipefd[1], id, name));}
}
//测试函数,纯输入函数
//输入：const &
//输出：*
//输入输出：&
void debug(const vector<channel>& channels)
{for(auto&e : channels){cout<< e._cmdfd <<" "<<e._slaverid<<" "<<e._processname<<endl;}}void Loadtask(vector<task_t> *tasks)
{ tasks->push_back(task1);tasks->push_back(task2);tasks->push_back(task3);tasks->push_back(task4);
}
void memu()
{cout<< "########################" <<endl;cout<< "1:lol 刷新日志 2:lol 更新野区" <<endl;cout<< "1:lol 检测软件更新 4:lol 释放技能" <<endl;cout<< " 0:退出 " <<endl;cout<< "########################" <<endl;
}
//2:开始控制子进程
void ctrlSlaver(vector<channel> &channels)
{int which = 0;int cnt = 5;while(true){int select = 0;memu();cout<< "Please Enter@:";cin>> select;if(select == 0) break;//1：选择任务//int cmdcode = rand()%tasks.size();int cmdcode = select - 1;//2：随机选择进程//int processpos = rand()%channels.size();//2：轮询选择进程cout<< "father say:"<< "cmdcode:" << cmdcode << " already sendto " <<channels[which]._slaverid << "process name " <<channels[which]._processname << endl;//3：发送任务write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));which++;which%=channels.size();//保证不大于其长度cnt--;if(cnt == 0) break;sleep(1);}
}
void QuitProcess(const vector<channel> &channels)
{for(const auto& e : channels) close(e._cmdfd);sleep(10);for(const auto& e : channels) waitpid(e._slaverid, nullptr, 0);//进程的pid=_slaverid，关上了以后记得回收
}int main()
{Loadtask(&tasks);//srand(time(nullptr)^getpid()^1023);//种一个随机数种子//在组织vector<channel> channels;//1:初始化Init(channels);debug(channels);//2:开始控制子进程ctrlSlaver(channels);//3:清理收尾QuitProcess(channels);return 0;
}
