论坛 › 运维.售后 › 匿名管道 Linux

丝 发表于 6 天前

匿名管道 Linux

目录
管道
pipe创建一个管道
让子历程写入，父历程读取
如何把消息发送/写入给父历程
父历程该怎么读取呢
管道本质
结论：管道的特征：
测试管道大小
写端退了，测试结果
测试子历程不停写，父历程读一会就退出
管道到的应用场景
写一个历程池(pipe_use)
思绪步调
管道创建
创建父子历程
父历程写，子历程读

子历程pid有了管道也有了，就差在父历程添加字段了
先更改一下，在class里构造一下
添加字段
把初始化改造成函数
debug测试函数，纯输入函数
第二步开始控制历程了（想让子历程做什么）
改变一下，直接从键盘（0号形貌符）里读，不从管道（3）里读了，就没有管道的概念了，slaver就不消传参了，父历程通过管道写，子历程通过标准输入读
如今开始选择任务和历程
也可以轮询选择，界说一个计数器，++弄，再%等
清算收尾
bug的地方：
​编辑
以上是匿名管道 
总文件总代码
makefile中代码
Task.hpp中代码
ProcessPool.cc中代码

管道

起首自己要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区里面），然后用户层缓冲区通过体系调用（write）写到管道里，然后再通过read体系调用，被对方（读端）读取，就要从管道拷贝到读端，然后再表现到表现器上。
pipe创建一个管道

pipe的先容https://i-blog.csdnimg.cn/direct/508c1018ac4246e9abf452ca6e20742e.png
1完成这件事：https://i-blog.csdnimg.cn/direct/04ec1a4f71864fbd82d7959a8e9ac36e.png
看图分析
https://i-blog.csdnimg.cn/direct/054d3d1487164e52b373b4cb4c2f588b.png
运行结果
https://i-blog.csdnimg.cn/direct/fbe8a521cba342479cbcfbae14359066.png
#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{
    //创建管道
    //先创建一个pipefd数组
    int pipefd;
    //用n接受一下，判断是否成功
    int n = pipe(pipefd);
    if(n<0) return 1;//创建失败了

    //创建成功
    //测试一下文件描述符是3和4
    cout<<"pipefd:"<<pipefd<<"pipefd:"<<pipefd<<endl;
   

    return 0;
}

2完成这件事：
https://i-blog.csdnimg.cn/direct/df704c13450d4b1a9b2ad5510bcd4263.png
创建一个子历程
https://i-blog.csdnimg.cn/direct/4a2daa7208dd438b8394aa63eb5927ca.png
pid_t id = fork();
    if(id < 0)return 2;//创建失败
    if(id == 0)//创建成功
    {
      //子进程

    }
    //父进程
让子历程写入，父历程读取

https://i-blog.csdnimg.cn/direct/e133ebd7c8fb4c0097dfe38530e188cc.png
要想让子历程历程写，就需要在历程中关闭读端
https://i-blog.csdnimg.cn/direct/463e5d68265747a6b7705673796d46cd.png
if(id == 0)//创建成功
{
   //子进程
   close(pipefd);
} 同理
https://i-blog.csdnimg.cn/direct/92ef35f4ae144f2dbd75381bac778758.png
//父进程
close(pipefd); 都用完结束后，可以都关掉
https://i-blog.csdnimg.cn/direct/0834fbd3d84d447a9f2c886ab48a52fa.png
    if(id == 0)//创建成功
    {
      //子进程
      close(pipefd);
      //.....
      close(pipefd);
    }
    //父进程
    close(pipefd);
    //.....
    close(pipefd); IPC code，写通讯代码
3这件事也完成了：
https://i-blog.csdnimg.cn/direct/920301abdade4888a8e1fb7a4be9984d.png
结构就有了


然后在pipefd这个管道里写，界说一个Writer函数
https://i-blog.csdnimg.cn/direct/1c3e0706233f48a6b3d366037cb35406.png
    if(id == 0)//创建成功
    {
      //子进程
      close(pipefd);
      //.....IPC code，写通信代码
      //在pipefd这个管道里写
      Writer(pipefd);


      close(pipefd);

      exit(0);//正常退出
    } 同理父历程的        
https://i-blog.csdnimg.cn/direct/ab853bb9b81c4089a6c204493598740f.png
    //父进程
    close(pipefd);
    //.....IPC code，写通信代码
    //在pipefd这个管道里写
    Reader(pipefd);


    close(pipefd); https://i-blog.csdnimg.cn/direct/cfd3d99eb611447b9acb626ff40ac6bc.png
//子进程
void Writer(int wfd)
{

}
//父进程
void Reader(int rfd)
{

} Writer
https://i-blog.csdnimg.cn/direct/84be68a7b3354d15a4c73a7b3ecb025a.png
//子进程
void Writer(int wfd)
{
    string s = "hello,I am child";
    pid_t self = getpid();
    int number = 0;

    char buffer;
    while(true)
    {
      buffer = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了

    }
}
用到snprintf
先容https://i-blog.csdnimg.cn/direct/d054e008896a4fa2b5eaf7e959ff9011.png
将s和self和number放进buffer
https://i-blog.csdnimg.cn/direct/a1372509a0c94ecda036882aefa3885b.png
char buffer;
    while(true)
    {
      buffer = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了
      snprintf(buffer,sizeof(buffer),"%s    pid:%d\n",s.c_str(),self);
      cout<< buffer <<endl;
      sleep(1);
    }; 用cout打印测试一下，打印成功分析写入buffer成功了

等待历程少不了，子历程exit后需要回收
https://i-blog.csdnimg.cn/direct/b6fd3165246f48cc8c1f498c587afd02.png
//父进程
    close(pipefd);
    //.....IPC code，写通信代码
    //在pipefd这个管道里写
    Reader(pipefd);

    //等待进程缺少不了
    pid_t rid = waitpid(id,nullptr,0);
    if(rid < 0) return 3;//等待失败了

    close(pipefd);
如何把消息发送/写入给父历程

用到了write
https://i-blog.csdnimg.cn/direct/dd98aa8019264ae0a3fbde06b60a00ee.png

用write写入管道（管道也是文件），用strlen，不消+1，不消管\0，由于C语言规定\0末端，和文件没有关系，wfd写入管道
https://i-blog.csdnimg.cn/direct/d8931bb680914882b25db2777cda88c6.png
//子进程
void Writer(int wfd)
{
    string s = "hello,I am child";
    pid_t self = getpid();
    int number = 0;
    char buffer;
    while(true)
    {
      buffer = 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
https://i-blog.csdnimg.cn/direct/37502e652079464f85cadf5554c19c3d.png
这里就需要思量到\0，由于buffer中需要\0
https://i-blog.csdnimg.cn/direct/82df80577eca459cb017a488eea93fb0.png
//父进程
void Reader(int rfd)
{
    char buffer;
    while(true)
    {
      buffer = 0;
                                    //用sizeof是为了留个空间放\0
      ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlen
      if(n > 0)
      {
            //添加\0，因为要放在buffer数组中读取
            buffer=0;
            cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;
      }
    }
} 运行结果
也会发现：为什么子历程sleep，父历程不sleep，父历程还是会跟着子历程sleep，由于父子历程是要协同的
https://i-blog.csdnimg.cn/direct/6ec70a333f294e2f8ed04f6eabd40aa1.png
管道本质

通讯是为了更好的发送变化的数据，管道本质上是文件
所以必须要用到体系调用接口来访问管道，其是由体系管理，read和write
，操作体系相当于中介 
结论：管道的特征：

1：具有血缘关系的历程进行历程间通讯
2：管道只能单向通讯
3：父子历程是会历程协同的，同步与互斥的--掩护管道文件的数据安全
4：管道是面向字节省的
5：管道是基于文件的，而文件的生命周期是随历程的

再测试，把子历程sleep去掉，就是让子历程写快一点，父历程sleep几秒，就是让父历程读慢一点，看有什么现象

 管道的四种环境
https://i-blog.csdnimg.cn/direct/a962a8edefb94de096482414f621de68.png
https://i-blog.csdnimg.cn/direct/3e989e21d2ed47b9ab785e9f6caa0495.png
https://i-blog.csdnimg.cn/direct/87d8448e3ae84a6dbd014ba8998dc156.png
https://i-blog.csdnimg.cn/direct/8c29e9dfe2a448bd86de57448e4c3df3.png
https://i-blog.csdnimg.cn/direct/b8939b281e9146d689f2176765182bb5.png
测试管道大小

把c不停往管道里写，把父历程中休眠50秒
https://i-blog.csdnimg.cn/direct/c1735eb26fac4137ae7199fbde1ee891.png
https://i-blog.csdnimg.cn/direct/f7ff3f72faf94cd5814dcc10c30371d6.png
结果差不多64kb
https://i-blog.csdnimg.cn/direct/5ffad034b0de4533846b7b37ff8682b7.png


写端退了，测试结果

https://i-blog.csdnimg.cn/direct/135e56b19f79442bb24bc6b723215cd6.png
结果是：
读端正常读，写端关闭，读端就会读到0，表明读到了文件（pipe）末端，不会被阻塞
read读取成功会返回读到的字符个数，读到末端返回0
https://i-blog.csdnimg.cn/direct/2d76269839db4468b4d79876e4e86491.png

读到末端父历程也就可以制止读取了，break后去把僵尸的子历程回收
https://i-blog.csdnimg.cn/direct/9d9849bf87a949baabe8a2692b84c152.png
break到这里
https://i-blog.csdnimg.cn/direct/64f13a34af1d4fdab7161056b6eb2dc6.png
最后子历程会被waitpid回收

测试子历程不停写，父历程读一会就退出

界说一个cnt控制退出的时间
https://i-blog.csdnimg.cn/direct/b0e1cb2e58c549ceb6e7acdc1e1c7eb0.png
这里也要修改一下，加个sleep(5),观察，close提前关闭
https://i-blog.csdnimg.cn/direct/1748ae9779c646f58639acf21da3fd90.png
https://i-blog.csdnimg.cn/direct/7e0b6fc04acc4aefb744be2fdc4898ba.png
结果：通过13号信号杀死 
https://i-blog.csdnimg.cn/direct/28a587c03006473f8d8e7758ded4f09f.pnghttps://i-blog.csdnimg.cn/direct/41b6d86cd9f64fda81982b7799b534df.png

管道到的应用场景

https://i-blog.csdnimg.cn/direct/db53ac35c459428a84527122697043be.png
都会酿成一个历程
https://i-blog.csdnimg.cn/direct/77e37c2e219148b588738f19044d41cd.png


写一个历程池(pipe_use)

起首创建好文件
https://i-blog.csdnimg.cn/direct/aafbc31744b34d2ca1aecb2e5ccfd21f.png

创建5个历程

channel通道的意思
cmdfd文件形貌符
slaverid代表哪个子历程
https://i-blog.csdnimg.cn/direct/8138ea2229ad4553b2afeaf60a7ccc3e.png
https://i-blog.csdnimg.cn/direct/3d0b81d04dfc43dba6d581f48d53a006.png

把它放进vector容器里

思绪步调

https://i-blog.csdnimg.cn/direct/bfd86ad5e34848d69eb3f3581283f964.png

管道创建

void（n），假装使用一下，要不然编译不外
https://i-blog.csdnimg.cn/direct/bb0c82dc0fe5402bb03bb2725726dc79.png
创建父子历程

https://i-blog.csdnimg.cn/direct/e629ddfc1c0b40b78d0305a792ff77af.png
父历程写，子历程读

子历程要读取，就要关闭自己的写端，父历程同理
https://i-blog.csdnimg.cn/direct/1c8a9f9ca8504f4fba79672c22e31367.png
子历程中的任务
https://i-blog.csdnimg.cn/direct/ab1a9dde70fb4ab592f68022b079887b.pnghttps://i-blog.csdnimg.cn/direct/b458362207ab4a4bb13f30bba05d47e8.png


子历程pid有了管道也有了，就差在父历程添加字段了


先更改一下，在class里构造一下

https://i-blog.csdnimg.cn/direct/1230daca85bc45c2bd85332984b717eb.png

添加字段

https://i-blog.csdnimg.cn/direct/f7ef72e12c324b309110944fb7ee25d2.png
测试一下：结果：文件形貌符0，1，2是默认打开，3是从管道里读，4是写入管道
https://i-blog.csdnimg.cn/direct/bea0d88de03e4425923c341791179d44.png

把初始化改造成函数

https://i-blog.csdnimg.cn/direct/6becaac443c047ce940c74898013e3bc.png
https://i-blog.csdnimg.cn/direct/5704c86a61c64b19b66e526f8d50b4ef.png


debug测试函数，纯输入函数

https://i-blog.csdnimg.cn/direct/6dfc2363bce44610af19a1356194101e.png
https://i-blog.csdnimg.cn/direct/2ac41151de3a4694a80bd0ee1ac4cb26.png

第二步开始控制历程了（想让子历程做什么）

https://i-blog.csdnimg.cn/direct/8e21d2884ffa493eb79a245ff78080cc.png
这里打印的rfd都是3，正常吗，文件形貌符是可以被子历程继承的

父历程对应的写端拿到的是4-8，子历程拿到的读端fd是3
https://i-blog.csdnimg.cn/direct/c34c5b8df6244a8eb9d0fd6b9211ac89.png

改变一下，直接从键盘（0号形貌符）里读，不从管道（3）里读了，就没有管道的概念了，slaver就不消传参了，父历程通过管道写，子历程通过标准输入读

用到了dup2，将从pipefd中读酿成从0开始读
https://i-blog.csdnimg.cn/direct/b5319ca1b2104b5d8b894b3bdb457120.png
https://i-blog.csdnimg.cn/direct/4c3142b16dd14ed98118074cba038c02.png
想让父历程固定的向管道里写入指定大小字节的内容，必须读取四个字节，四个字节四个字节的写和读，这里的管道64kb
必须读取四个字节
https://i-blog.csdnimg.cn/direct/5c098cba66244255844fd4e6eab33d1e.png

如果父历程不给子历程发送数据呢？阻塞等待!
https://i-blog.csdnimg.cn/direct/b767dc88c7b54ba1af04ab11c5b11add.png


开始控制子历程
https://i-blog.csdnimg.cn/direct/6bfc2597eda24fa997d5c6dadc248add.png

生成一个随机数种子
https://i-blog.csdnimg.cn/direct/9da66ec5c9404ee8ab8f01bc0080867d.png
可以随机选择任务和选择历程
https://i-blog.csdnimg.cn/direct/815f9f4ab185486492353bc1f951ab8a.png
https://i-blog.csdnimg.cn/direct/d54bda92a21245e0915319930024926e.png
https://i-blog.csdnimg.cn/direct/231f3975cd614fe69010d47f2ebf4bd8.png

cmd是任务码，测试一下，父历程控制子历程,父历程发送给子历程（通过cmdcode连续）
https://i-blog.csdnimg.cn/direct/e9b78fb87b03481a8c73de27f3ba409e.png
https://i-blog.csdnimg.cn/direct/3a97a0787d70494aacf3cdc6adcf366b.png

在Task.hpp里
https://i-blog.csdnimg.cn/direct/a57cad05bb3e47a0b54ce53570898fa6.png

要用到函数指针
https://i-blog.csdnimg.cn/direct/cb1d20b0273e44e69fddc1ad1d90752e.png

main中的任务了就属于
https://i-blog.csdnimg.cn/direct/e3d0685c247748aebb87e4f8802737f6.png
再把任务装载进来
https://i-blog.csdnimg.cn/direct/a5db4049ea6a4054bb29836e79c64694.png

输出型参数用*
https://i-blog.csdnimg.cn/direct/1130b892287e429e98cf541cbcc600c5.png

如今开始选择任务和历程

https://i-blog.csdnimg.cn/direct/ee142fe095a04e058f2db57219205a75.png
https://i-blog.csdnimg.cn/direct/967799960fd14fdc92a00f48c218f1ba.png

再把main中的任务弄成全局的
https://i-blog.csdnimg.cn/direct/73bd6d9e04904857837b5787b197e6ca.png

进行判断一下
https://i-blog.csdnimg.cn/direct/b3b103abb7a04a2483f79aa8b2b2b17e.png

测试 ,comcode和任创建的任务同等
https://i-blog.csdnimg.cn/direct/fa08b4b28ce1490fa20bf48d5c75f6f3.png

这里的write是父历程进行写入，向子历程发送，子历程不得闲，先写到管道里，等得闲了再读
https://i-blog.csdnimg.cn/direct/2488326798ce40e7a8bc66c601cf1427.png

也可以轮询选择，界说一个计数器，++弄，再%等



整理一下控制代码，这里是输入型参数，只需要读
https://i-blog.csdnimg.cn/direct/eca45e533250462d9ebdb2a9df88ab5c.png
https://i-blog.csdnimg.cn/direct/a583fc02d342447b8e75bc6250b79a3b.png

这样就可以轮询方式选择历程了，不消随机了
https://i-blog.csdnimg.cn/direct/fdb9b83a03a34f5d923dc2ecca9d3ca8.png
结果
https://i-blog.csdnimg.cn/direct/0676da99729f467fba058b5766b37d06.png


清算收尾

思绪：把所有文件的形貌符都关掉
https://i-blog.csdnimg.cn/direct/e48497f8316b48a994cdd63e15766f68.png
https://i-blog.csdnimg.cn/direct/18f77cc10959438fb577e1eaac0a3636.png

等待方式设置为0 
https://i-blog.csdnimg.cn/direct/0850cf4313b641839a792d9a5eb52ae7.png

read返回0，就是失败了，然后slaver就会调完
https://i-blog.csdnimg.cn/direct/f797cb8be7e44011aa12ea10ddbdd90c.png
结束完就会exit直接退出
https://i-blog.csdnimg.cn/direct/0389505aad474b7aae38b3eed54c723b.png
打印下更好表现
https://i-blog.csdnimg.cn/direct/0d2250d2c9ee44a6baee8a2ada035a01.png

关闭文件形貌符后sleep(10)秒，
https://i-blog.csdnimg.cn/direct/753bc968b40a4615bec34a73b36e591c.png

然后这10个子历程一瞬间都应该break，然后最后到exit直接就退了，10秒结束后，父历程再回收他       

测试时不弄死循环，用cnt，5秒后主动结束控制，正常退出流程
https://i-blog.csdnimg.cn/direct/f0e59176bd914da9958e9c7851ec542b.png


测试结果
https://i-blog.csdnimg.cn/direct/42bfdc1cf3b24cdfa68e42cbcb9a06f7.png

手动控制一下
https://i-blog.csdnimg.cn/direct/ff6e5269ce0b4c6ca013a221bf1f76db.png
界说一个select，输入0就是退出了，判断完后，就走到了选择任务
https://i-blog.csdnimg.cn/direct/bc87e1d0c8d146d2bfc105095ac2a49c.png
然后直接把cmdcode改为选择的select，-1是由于是从下标0开始的，输入1就是0下标的
https://i-blog.csdnimg.cn/direct/113059d8611d4613b4e2145de04742b2.png
测试
https://i-blog.csdnimg.cn/direct/6d0e0f8fc471487ea75ec581d58e5182.png

bug的地方：

这样会有一些bug（一个子历程不是只有一个写端（每一次子历程的创建都是有继承））
 这样会有一些bug（一个子历程不是只有一个写端（每一次子历程的创建都是有继承））https://i-blog.csdnimg.cn/direct/8487a9424017496cab60b808c75f7492.png

https://i-blog.csdnimg.cn/direct/d8e3f5b662264e8cb48691ca8655bd43.png


按理说这样是对的，可是这样就错了
https://i-blog.csdnimg.cn/direct/7f1507e95a3747f6944abc7a99764da9.png由于下面两个红线还没有关掉，它们历程了最开始的w
https://i-blog.csdnimg.cn/direct/0bee7551c7c0445a94be1fb46c9c7d0c.png


这样倒着回收是可以的
https://i-blog.csdnimg.cn/direct/ea80eb8d7c114f3e916c2a8e2a86e399.png


精确改法
https://i-blog.csdnimg.cn/direct/499317be7a7e4a60a9099277765ce1ed.png




修改一下
https://i-blog.csdnimg.cn/direct/f10217fe05a4490fbae8b041bfe914a2.png
最后一个push_back的就都是父历程的写入fd，

然后加一句这个红线的，每创建子历程后都先把上一次父历程的读端fd关掉就可以了，这里很妙，由于vector一开始是空的
https://i-blog.csdnimg.cn/direct/902adbf0c39f4788a42f63e3abd9b987.png
方便看
https://i-blog.csdnimg.cn/direct/47b2f0021850446285ad623a5de8601f.png

这里这样就可以了        
https://i-blog.csdnimg.cn/direct/cc5b62fcba0f4c449d6668a3a16d0114.png


管道已经完成
https://i-blog.csdnimg.cn/direct/d30b136d5fe542f2bfba81bdff58a82c.png

以上是匿名管道 


总文件总代码

https://i-blog.csdnimg.cn/direct/a92d09507bb04e819bc3e6974ba18159.png
makefile中代码

ProcessPool:ProcessPool.cc
        g++ -o $@ $^ -std=c++11
.PHNOY:clean
clean:
        rm -f ProcessPool Task.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中代码

留意：https://i-blog.csdnimg.cn/direct/cae5a750b48f46b2963271be4648b7fe.png
这里为啥是取地址一个comcode，不是一个0吗，要发送的数据就是这个，所以要把地址传给函数，可以是个数组
https://i-blog.csdnimg.cn/direct/c8172b4eeed74858aa2be2f04f15315c.png
换成数组的话，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();
      }
      if(n == 0) break;
    }
}

//初始化
void Init(vector<channel>& channels)
{
    for(int i =0;i < processnum;i++)
    {
      int pipefd;
      int n = pipe(pipefd);//创建管道
      //返回值小于0就创建失败了
      assert(!n);
      (void)n;

      pid_t id = fork();
      if(id == 0)
      {
            //子进程：读
            close(pipefd);

            //改变一下从fd为0的地方读
            dup2(pipefd,0);
            close(pipefd);
            //任务
            slaver();
            cout<< "process: " << getpid() << "quit" <<endl;
            //slaver(pipefd);

            exit(0);
      }
      //父进程：写
      close(pipefd);
      //channel添加字段
      string name = "processs-" + to_string(i);
      //插入的是自定义类型，要构造一下，第一个传的是文件描述符，要写入的fd
      channels.push_back(channel(pipefd, 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._slaverid << "process name   "
            <<channels._processname << endl;

      //3：发送任务
      write(channels._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;
}



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

查看完整版本: 匿名管道 Linux