Linux进程通信之管道通信
我们都知道，进程之间都是相互独立的，为了实现进程间能够互相传输数据便有了进程间通信。进程间通信分为三类，第一类是基于文件系统的管道通信，第二类是基于system v标准的本地通信，第三类是基于POSIX标准，能够实现跨主机的通信。今天我们所要探讨的是第一大类管道通信。在认识管道通信之前，我们得先知道什么是管道。
管道的概念
我们拿自来水管道来举例，自来水管道里面的水从一头流向另一头。在计算机世界里，管道的两端是两个进程，水流就相当于两个进程之间传输的数据。那这个管道到底是什么呢？我们用一张图来表示它：
管道是属于内核的，所以os为我们提供了创建管道的系统调用，这个我们后面再讲。现在我们来谈一谈为什么要使用管道这个东西。
有人就有疑问，管道是基于文件系统的内存级文件，这句话是怎么理解的？
在解答这个问题之前，我们思考一下，如果想基于文件系统实现两个进程的通信很简单：在磁盘中创建一个文件，一个进程写，文件先被加载到内存中再将数据写到文件中最后定期刷新到磁盘上。一个进程读，将文件加载到内存中，再从内存中读取数据。文件的IO大大降低了进程间的通信效率。所以管道是基于文件系统的，目的是和别的文件一样可以进行读写。管道也是一个内存级文件，原因就在于它是被创建在内存里的，各个进程进行数据的传输只需要和内存打交道，和磁盘无关，提高了数据通信的效率。
匿名管道
管道分为匿名管道和命名管道。当我们一个进程通过系统调用创建出一个管道时，因为管道是一个基于文件系统的内存级文件。所以打开这个文件时，进程的文件描述符表就存有该文件的描述符。该文件有两个描述符，一个是读端描述符，一个是写端描述符：
可是进程与进程之间是相互独立的，那么如何让另一个进程看到这个管道呢？我们可以通过fork创建子进程的方式，这样子进程就继承了父进程的文件描述符表，通过文件描述符表就可以找到同一个管道了：
为了让两个进程各个执行自己的读写任务，我们可以关闭它们任务除外的文件描述符：
所以我们称有血缘关系间的进程通信所使用的管道为匿名管道。它的系统调用接口是pipe：
pipefd 数组里存放的是管道的读写文件描述符，pipefd[0]是读端描述符，pipefd[1]是写端描述符。现在我们就尝试实现父子进程之间的通信：
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
// 父进程进行读取，子进程进行写入
int main()
{
// 第一步：创建管道文件，打开读写端
int fds[2];
int n = pipe(fds);
assert(n == 0);
// 第二步: fork
pid_t id = fork();
assert(id >= 0);
if (id == 0)
{
// 子进程进行写入
close(fds[0]);
// 子进程的通信代码
// string msg = "hello , i am child";
const char *s = "我是子进程,我正在给你发消息";
int cnt = 0;
while (true)
{
cnt++;
char buffer[1024]; // 只有子进程能看到！
snprintf(buffer, sizeof buffer, "child->parent say: %s[%d][%d]", s, cnt, getpid());
// 写端写满的时候，在写会阻塞，等对方进行读取!
write(fds[1], buffer, strlen(buffer));
cout << "count: " << cnt << endl;
// sleep(50); //细节，我每隔1s写一次
// break;
}
// 子进程
close(fds[1]); // 子进程关闭写端fd
cout << "子进程关闭自己的写端" << endl;
// sleep(10000);
exit(0);
}
// 父进程进行读取
close(fds[1]);
// 父进程的通信代码
while (true)
{
sleep(2);
char buffer[1024];
// cout << "AAAAAAAAAAAAAAAAAAAAAA" << endl;
// 如果管道中没有了数据，读端在读，默认会直接阻塞当前正在读取的进程！
ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
// cout << "BBBBBBBBBBBBBBBBBBBBBB" << endl;
if (s > 0)
{
buffer[s] = 0;
cout << "Get Message# " << buffer << " | my pid: " << getpid() << endl;
}
else if(s == 0)
{
//读到文件结尾
cout << "read: " << s << endl;
break;
}
break;
// 细节：父进程可没有进行sleep
// sleep(5);
}
close(fds[0]);
cout << "父进程关闭读端" << endl;
int status = 0;
n = waitpid(id, &status, 0);
assert(n == id);
cout <<"pid->"<< n << " : "<< (status & 0x7F) << endl;
return 0;
} 管道的读写规则：
当没有数据可读时：
O_NONBLOCK disable ： read 调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable ： read 调用返回 -1 ， errno 值为 EAGAIN 。
当管道满的时候：
O_NONBLOCK disable ： write 调用阻塞，直到有进程读走数据
O_NONBLOCK enable ：调用返回 -1 ， errno 值为 EAGAIN
如果所有管道写端对应的文件描述符被关闭，则 read 返回 0
如果所有管道读端对应的文件描述符被关闭，则 write 操作会产生信号 SIGPIPE, 进而可能导致 write进程收到信号被杀死
用匿名管道实现进程池：
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MakeSeed() srand((unsigned long)time(nullptr) ^ getpid() ^ 0x171237 ^ rand() % 1234)
#define PROCSS_NUM 10
///子进程要完成的某种任务 -- 模拟一下/
// 函数指针 类型
typedef void (*func_t)();
void downLoadTask()
{
std::cout << getpid() << ": 下载任务\n"
<< std::endl;
sleep(1);
}
void ioTask()
{
std::cout << getpid() << ": IO任务\n"
<< std::endl;
sleep(1);
}
void flushTask()
{
std::cout << getpid() << ": 刷新任务\n"
<< std::endl;
sleep(1);
}
void loadTaskFunc(std::vector *out)
{
assert(out);
out->push_back(downLoadTask);
out->push_back(ioTask);
out->push_back(flushTask);
}
/下面的代码是一个多进程程序//
class subEp // Endpoint
{
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_;
int writeFd_;
};
int subEp::num = 0;
int recvTask(int readFd)
{
int code = 0;
ssize_t s = read(readFd, &code, sizeof code);
if(s == 4) return code;
else if(s <= 0) return -1;
else return 0;
}
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));
assert(n == sizeof(int));
(void)n;
}
void createSubProcess(std::vector *subs, std::vector &funcMap)
{
std::vector deleteFd;
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)
{
for(int i = 0; i < deleteFd.size(); i++) close(deleteFd[i]);
// 子进程, 进行处理任务
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);
deleteFd.push_back(fds[1]);
}
}
void loadBlanceContrl(const std::vector &subs, const std::vector &funcMap, int count)
{
int processnum = subs.size();
int tasknum = funcMap.size();
bool forever = (count == 0 ? true : false);
while (true)
{
// 1. 选择一个子进程 --> std::vector -> index - 随机数
int subIdx = rand() % processnum;
// 2. 选择一个任务 --> std::vector -> index
int taskIdx = rand() % tasknum;
// 3. 任务发送给选择的进程
sendTask(subs[subIdx], taskIdx);
sleep(1);
if(!forever)
{
count--;
if(count == 0) break;
}
}
// write quit -> read 0
for(int i = 0; i < processnum; i++) close(subs[i].writeFd_); // waitpid();
}
void waitProcess(std::vector processes)
{
int processnum = processes.size();
for(int i = 0; i < processnum; i++)
{
waitpid(processes[i].subId_, nullptr, 0);
std::cout << "wait sub process success ...: " << processes[i].subId_ << std::endl;
}
}
int main()
{
MakeSeed();
// 1. 建立子进程并建立和子进程通信的信道, 有bug的，但是不影响我们后面编写
// 1.1 加载方发表
std::vector funcMap;
loadTaskFunc(&funcMap);
// 1.2 创建子进程，并且维护好父子通信信道
std::vector subs;
createSubProcess(&subs, funcMap);
// 2. 走到这里就是父进程, 控制子进程，负载均衡的向子进程发送命令码
int taskCnt = 3; // 0: 永远进行
loadBlanceContrl(subs, funcMap, taskCnt);
// 3. 回收子进程信息
waitProcess(subs);
return 0;
} 进程池的代码有一点难度，需要自己实现并加以理解，这里我们就不多说了。现在我为大家讲一讲不用基于血缘关系通信的管道：命名管道。
命名管道：
可以应用于两个毫无关系的进程进行通信（没有血缘关系），调用fifo接口创建一个管道文件。我们称该管道为命名管道。命名管道是一个特殊类型的文件。
创建命名管道的接口：
int mkfifo(const char *filename,mode_t mode);
mode是权限，例如我们这是0600，这样只有使用者可以使用这个管道文件了。
通过命名管道，我们可以实现一个，客户端和服务器之间的通信：
comm.hpp:
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define NAMED_PIPE "/tmp/mypipe.106"
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); // debug , release 里面就没有了
(void)n;
} client.cc:
#include "comm.hpp"
// 你可不可以把刚刚写的改成命名管道呢！
int main()
{
std::cout << "client begin" << std::endl;
int wfd = open(NAMED_PIPE, O_WRONLY);
std::cout << "client end" << std::endl;
if(wfd < 0) exit(1);
//write
char buffer[1024];
while(true)
{
std::cout << "Please Say# ";
fgets(buffer, sizeof(buffer), stdin); // abcd\n
if(strlen(buffer) > 0) buffer[strlen(buffer)-1] = 0;
ssize_t n = write(wfd, buffer, strlen(buffer));
assert(n == strlen(buffer));
(void)n;
}
close(wfd);
return 0;
}server.cc:
#include "comm.hpp"
int main()
{
bool r = createFifo(NAMED_PIPE);
assert(r);
(void)r;
std::cout << "server begin" << std::endl;
int rfd = open(NAMED_PIPE, O_RDONLY);
std::cout << "server end" << std::endl;
if(rfd < 0) exit(1);
//read
char 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, me too!" << std::endl;
break;
}
else
{
std::cout << "err string: " << strerror(errno) << std::endl;
break;
}
}
close(rfd);
// sleep(10);
removeFifo(NAMED_PIPE);
return 0;
}
匿名管道和命名管道的区别：
1.匿名管道由 pipe 函数创建并打开。 命名管道由mkfififo 函数创建，打开用 open2.FIFO （命名管道）与 pipe （匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。
命名管道的打开规则
如果当前打开操作是为读而打开 FIFO 时O_NONBLOCK disable ：阻塞直到有相应进程为写而打开该 FIFOO_NONBLOCK enable ：立刻返回成功如果当前打开操作是为写而打开 FIFO 时O_NONBLOCK disable ：阻塞直到有相应进程为读而打开该 FIFO O_NONBLOCK enable：立刻返回失败，错误码为 ENXIO
到这里进程间通信之管道通信就全部结束了，希望大家多多支持，共同进步！