#include <iostream>#include <unistd.h>#include <cstdio>#include <cassert>#include <cstring> #include <sys/types.h>#include <sys/wait.h>usingnamespacestd;
//子进程写入，父进程读取intmain()
{
// 第一步：创建管道文件，打开读写端intfds[2];
intn=pipe(fds);
assert(n==0);//否则创建管道失败，直接断言//创建子进程pid_tid=fork();
assert(id>=0);//否则创建子进程失败//子进程通信代码--子进程写入if(id==0)
    {
//关闭读端，写端打开close(fds[0]);
constchar*s="我是子进程，我正在给你发消息";
intcnt=0;
while(true)
        {
++cnt;
charbuffer[1024];//只能在子进程看到snprintf(buffer, sizeofbuffer, "child -> parent say: %s[%d][子进程pid:%d]", s, cnt, getpid());
write(fds[1], buffer, strlen(buffer));
sleep(3);
if(cnt>=10)
break;
        }
close(fds[1]);
cout<<"子进程关闭自己的写端"<<endl;
exit(0);
    }
//父进程通信代码--父进程读取close(fds[1]);
while(true)
    {
sleep(1);
charbuffer[1024];
ssize_ts=read(fds[0], buffer, sizeof(buffer)-1);
if(s>0)//读取到数据        {
buffer[s] ='\0';//防止越界cout<<"Get Message# "<<buffer<<" | 父进程pid: "<<getpid() <<endl;
        }
elseif(s==0) //读到文件结尾        {
cout<<"父进程读取完成"<<endl;
break;
        }
    }
close(fds[0]);
cout<<"父进程的读端关闭"<<endl;
//等待子进程intstatus=0;
n=waitpid(id, &status, 0);
cout<<"等待子进程pid->"<<n<<" : 退出信号："<< (status&0x7F) <<endl;
return0;
}

#include <iostream>#include <string>#include <vector>#include <ctime>#include <cassert>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>usingnamespacestd;
#define makeSeed() srand((unsigned long)time(nullptr) ^ getpid() ^ 0x363 ^ rand() % 1234)#define PROCESS_SUM 10typedefvoid (*func_t)();//函数指针类型//--------------------------------  模拟一下子进程要完成的某种任务  --------------------- voiddownloadTask()
{
cout<<getpid() <<"执行下载任务\n"<<endl;
sleep(1);
}
voidioTask()
{
cout<<getpid() <<"执行io任务\n"<<endl;
sleep(1);
}
voidflushTask()
{
cout<<getpid() <<"执行刷新任务\n"<<endl;
sleep(1);
}
voidloadTaskFunc(vector<func_t>*out)
{
assert(out);
out->push_back(downloadTask);
out->push_back(ioTask);
out->push_back(flushTask);
}
//--------------------------------  以下代码是多进程代码  --------------------- classsubEP//sub end point{
public:
subEP(pid_tsubId, intwriteFd)
        :_subId(subId)
        ,_writeFd(writeFd)
    {
charnameBuffer[1024];
snprintf(nameBuffer, sizeof(nameBuffer), "preocess - %d [pid(%d) - fd(%d)]", _num++, _subId, _writeFd);
_name=nameBuffer;
    }
public:
staticint_num;
string_name;
pid_t_subId;
int_writeFd;
};
intsubEP::_num=0;
intrecvTask(intreadFd)
{
intcode=0;
ssize_ts=read(readFd, &code, sizeofcode);
if(s==sizeof(code))//读取正常    {
returncode;
    }
elseif(s<=0)//读取出错    {
return-1;
    }
else    {
return0;
    }
}
voidcreateSubProcess(vector<subEP>*subs, vector<func_t>&funcMap)
{
//vector<int> deleteFd;//第一种方法：解决下一个子进程拷贝父进程读写端的问题for(inti=0; i<PROCESS_SUM; i++)
    {
intfds[2];
intn=pipe(fds);
assert(n==0);
        (void)n;
pid_tid=fork();
//子进程if(id==0)
        {
// for(int i = 0; i < deleteFd.size(); i++)//     close(deleteFd[i]);close(fds[1]);
while(true)
            {
//1.获取父进程发送的命令码，没有收到命令码，进行阻塞等待intcommandCode=recvTask(fds[0]);
//2.执行任务if(commandCode>=0&&commandCode<funcMap.size())
                {
funcMap[commandCode]();
                }
elseif(commandCode==-1)//读取失败返回-1                {
break;
                }
            }
//子进程退出exit(0);
        }
//父进程close(fds[0]);
subEPsub(id, fds[1]);
subs->push_back(sub);////deleteFd.push_back(fds[1]);    }
}
voidsendTask(constsubEP&process, inttaskNum)
{
cout<<"send tak num: "<<taskNum<<" send to -> "<<process._name<<endl;
intn=write(process._writeFd, &taskNum, sizeof(taskNum));
assert(n==sizeof(int));
    (void)n;
}
voidloadBlanceContrl(vector<subEP>&subs,  vector<func_t>&funcMap, intcount)
{
intprocessSum=subs.size();
inttaskSum=funcMap.size();
boolforever= (count==0?true : false);
while(true)
    {
// 1. 随机选择一个子进程intsubIdx=rand() %processSum;
// 2. 随机选择一个任务inttaskIdx=rand() %taskSum;
// 3. 任务发送给选择的进程sendTask(subs[subIdx], taskIdx);
sleep(1);
if(!forever)
        {
count--;
if(count==0)
break;
        }
    }
//第二种方法：解决下一个子进程拷贝父进程读写端的问题//写端退出，关闭读for(inti=0; i<processSum; i++)
    {
close(subs[i]._writeFd);
    }
}
voidwaitProcess(vector<subEP>process)
{
intprocessSum=process.size();
for(inti=0; i<processSum; i++)
    {
waitpid(process[i]._subId, nullptr, 0);
cout<<"wait sub process success ..."<<process[i]._subId<<endl;
    }
}
intmain()
{
//创建随机数makeSeed();
// 1.建立子进程并建立和子进程通信的信道// 1.1 加载方法任务表vector<func_t>funcMap;
loadTaskFunc(&funcMap);
// 1.2 创建子进程，并且维护父子通信信道vector<subEP>subs;
createSubProcess(&subs, funcMap);
// 2.父进程，控制子进程，负载均衡的向子进程发送命令码inttaskCnt=5;//执行任务次数，为0时永远执行任务loadBlanceContrl(subs, funcMap, taskCnt);
// 3.回收子进程waitProcess(subs);
return0;
}

mkfifo文件名ps: mkfifonamed_pipe

cnt=0; while :; doecho"hello world -> $cnt"; letcnt++; sleep2; done>named_pipe

头文件：#include <sys/types.h>#include <sys/stat.h>声明：intmkfifo(constchar*pathname, mode_tmode);
参数：（1）pathnamemkfifo函数的第一个参数是pathname，表示要创建的命名管道文件注意：若pathname以路径的方式给出，则将命名管道文件创建在pathname路径下若pathname以文件名的方式给出，则将命名管道文件默认创建在当前路径下（2）modemkfifo函数的第二个参数是mode，表示创建命名管道文件的默认权限返回值：命名管道创建成功，返回0命名管道创建失败，返回-1，错误码被设置

#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#define FILE_NAME "named_pipe"intmain()
{
umask(0); //将文件默认掩码设置为0//使用mkfifo创建命名管道文件intn=mkfifo(FILE_NAME, 0666);
if (n<0)
    { 
perror("mkfifo");
return-1;
    }
return0;
}

unlink头文件：#include <unistd.h>函数声明：intunlink(constchar*path);
参数：传入要被删除文件的名字返回值：删除成功返回0失败返回-1，错误码被设置

#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#define FILE_NAME "named_pipe"intmain()
{
umask(0); //将文件默认掩码设置为0//使用mkfifo创建命名管道文件intn=mkfifo(FILE_NAME, 0666);
if (n<0)
    { 
perror("mkfifo");
return-1;
    }
//删除管道文件n=unlink(FILE_NAME);
if(n<0)
    {
perror("unlink");
return-1;
    }
else    {
printf("管道文件删除成功\n");
    }
return0;
}

#pragma once#include <iostream>#include <string>#include <sys/types.h>#include <sys/stat.h>#include <unistd.h>#include <fcntl.h>#include <cassert>#include <cstring>usingnamespacestd;
#define NAMED_PIPE "named_pipe"//创建命名管道boolcreateFifo(conststring&path)
{
umask(0);
intn=mkfifo(path.c_str(), 0600);
if(n==0)//创建成功    {
returntrue;
    }
else//创建失败    {
cout<<"errno: "<<"errno string: "<<strerror(errno) <<endl;
returnfalse;
    }
}
//删除命名管道voidremoveFifo(conststring&path)
{
intn=unlink(path.c_str());
assert(n==0);//release下就没有了    (void)n;
}