目录
1.进程通信
1.1进程通信的概念
进程间通信指的是什么？两个或多个进程实现数据层面的交互。同时因为进程独立性的存在，导致进程通信测成本比较高。所以我们要知道通信是有成本的
1.2进程通信的目的
- 数据传输 ：不同进程间进行数据传输，比如此时我写的博客数据正在源源不断的上传至 CSDN 服务器中
- 资源共享 ：多个进程之间需要共享资源，假设每个用户都是独立的进程，那么整个 C 站就是一个被共享的资源，用户之前可以共享其技术资源
- 事件通知：一个进程向其他进程发送消息，通知处理相关事宜，比如 子进程终止时，需要通知父进程，回收其资源
- 进程控制：有些进程需要起到 管理者 的作用，于是需要与被管理进程之间构建通信关系，进程任务下达及进程控制，并对进程状态进行实时监视
1.3进程通信的本质
我们知道进程通信的概念之后，那我们该怎么办呢？
a.进程通信的本质：必须让不同进程看到同一份“资源”
b.“资源”就是特定形式的内存空间
c.这个资源由谁提供？一般是操作系统，为什么不是两个进程中的一个呢？因为假设一个进程提供，这个资源属于谁？这个进程独有的，会破坏进程独立性。所以要有第三方空间
d.我们进程访问这个空间，进行通信，本质就是访问操作系统！
1.4进程通信的标准
进程代表的就是用户，“资源”从创建，使用，释放都是要调用接口的！所以从底层设计，接口设计都要由操作系统设计，一般操作系统会有一个独立的通信模块，隶属于文件系统--IPC通信模块，
进程间通信都是有标准的------管道、systemV （本机内部）&&posix（网络）
管道：
- 匿名管道
- 命名管道
System V 标准：
System V消息队列System V共享内存System V信号量
POSIX 标准：
POSIX消息队列POSIX共享内存POSIX信号量POSIX互斥量（互斥锁）POSIX条件变量POSIX读写锁
2.管道
什么是管道？
在命令行中，我们输入两个指令中间用的|就是使用管道
例如
sleep 10000 | sleep 20000 &
可以看出，两个 sleep 进程的 PPID 一致，同时 PID 连续，因此这两个进程是兄弟关系
管道分为 匿名管道 和 命名管道，两者绝大部分原理、特点都一致，本文主要介绍 匿名管道，同时适用于 命名管道 的知识点统一称为 管道
2.1工作原理
管道的工作原理其实很简单：打开一个文件，让两个进程分别享有读端与写端 fd，对文件进行操作即可
具体在 OS 中的体现：在文件的结构体 files_struct 中，存在一个特殊的成员 struct file *fd_array[]，这是一个指针数组，其中存储的是指向不同文件的指针
//Linux内核源码（部分）
struct files_struct {
/*
* read mostly part
*/
atomic_t count;
struct fdtable __rcu *fdt;
struct fdtable fdtab;
/*
* written part on a separate cache line in SMP
*/
spinlock_t file_lock ____cacheline_aligned_in_smp;
int next_fd;
unsigned long close_on_exec_init[1];
unsigned long open_fds_init[1];
struct file __rcu * fd_array[NR_OPEN_DEFAULT]; //文件指针数组
};
此时父进程可以打开匿名管道文件，fork 子进程后，子进程继承原有的 文件系统 关系，与父进程共享同一份文件资源，然后父子进程分别关闭 读端与写端，实现匿名管道的单向关系，即可正常进行通信
具体流程：
父进程创建匿名管道，同时以读、写的方式打开匿名管道，此时会分配两个 fd
fork 创建子进程，子进程拥有自己的进程系统信息，同时会继承原父进程中的文件系统信息，此时子进程和父进程可以看到同一份资源：匿名管道 pipe
因为子进程继承了原有关系，因此此时父子进程对于 pipe 都有读写权限，需要确定数据流向，关闭不必要的 fd，比如父进程写、子进程读，或者父进程读、子进程写都可以
注意：
- fork 创建子进程后，子进程会继承原父进程中的文件系统信息，这也就是父子进程都会同时向屏幕打印信息的原理，因为此时它们操作的是同一个文件！
- 父进程需要以读写的方式打开匿名管道 pipe，这样子进程在继承时，才不会发生权限丢失
- 创建出的匿名管道文件 pipe 虽然属于文件系统，但它是一个特殊文件，一个由 OS 提供的纯纯的内存文件，不需要将数据冲刷至磁盘中，只需要承担进程间通信任务即可
- 管道是一种半双工、单流向的通信方式，因为 pipe 只有一个缓冲区，所以这种方式才被叫做 管道通信
2.2匿名管道
2.2.1接口pipe函数
#include <unistd.h>
int pipe(int pipefd[2]);
参数部分的pipefd是一个只有两个元素的整形数组，其中pipefd【0】为匿名管道的读端，pipefd【1】为匿名管道的写端
2.2.2代码演示
演示步骤：
- 创建匿名管道
- 创建子进程
- 关闭不需要的
fd - 开始通信
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
int main()
{
//创建匿名管道
int pipefd[2];
int ret = pipe(pipefd);
assert(ret == 0);
(void)ret;//防止release 报警
//创建子进程
pid_t id = fork();
if(id == 0)
{
//子进程
close(pipefd[1]);//关闭写端
//code
char buff[124];//缓冲区
while(true)
{
int n = read(pipefd[0],buff,strlen(buff)-1);//预留位置存‘\0'
buff[n] = '\0';
if (n >= 5 && n < 64)
{
// 读取到了信息
cout << "子进程成功读取到信息：" << buff << endl;
}
else
{
// 未读取到信息
if (n == 0)
cout << "子进程没有读取到信息，通信结束！" << endl;
// 读取异常（消息过短）
else
cout << "子进程读取数据量为：" << n << " 消息过短，通信结束！" << endl;
break;
}
}
close(pipefd[0]);//代码结束关闭读端
exit(0);
}
//父进程
close(pipefd[0]);
//code
//通信
char buff[124];
srand ((size_t)time(NULL));//种下一颗种子
while(true)
{
int n = rand() % 26;
for(int i = 0;i<n;i++)
buff[i] = (rand() % 26) + 'A';
buff[n] = '\n';
cout<<"==========="<<endl;
cout<< "我对你说："<<buff<<endl;
write(pipefd[1],buff,strlen(buff));
if (n < 5)
break; // 消息过短时，不写入
sleep(1);
}
close(pipefd[1]);
int status = 0;
waitpid(id,&status,0);
if ((status & 0x7F))
{
printf("子进程异常退出，core dump: %d 退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
}
else
{
printf("子进程正常退出，退出码：%d\n", (status >> 8) & 0xFF);
}
return 0;
}
站在 文件描述符 的角度理解上述代码：
站在 内核（管道本质） 的角度理解上述代码：
所以，看待 管道 ，就如同看待 文件 一样！管道 的使用和 文件 一致，迎合 Linux一切皆文件思想
2.3管道读写规则
管道是一种 半双工、单向流 的通信方式，因此在成功创建匿名管道后，需要两个待通信的进程都能获得同一个 pipefd 数组
这就是匿名管道比较特殊的地方了：匿名管道只支持具有血缘关系的进程通信，如 父子进程、兄弟进程等，因为只有 继承 了，才能共享到 同一个 pipefd 数组
当通信双方都获得 pipefd 数组后，需要根据情况关闭不需要的 fd，确保 单流向 的原则
注：命名管道可以支持不具有血缘关系进程间通信
管道的读写规则：
PIPE_BUF 为管道大小，Linux 中为 4096 字节
当要写入的数据量不大于 PIPE_BUF 时，Linux 将保证写入的原子性
当要写入的数据量大于 PIPE_BUF 时，Linux 将不再保证写入的原子性
原子性：不存在中间状态，确保数据的安全性
2.4管道的特点
管道 主要有以下几个特点：
1.单向通信，管道是半双工的一种特殊情况
- 管道就像单行道，只允许数据单向流通，即通知，如果想要实现两个进程间相互进行通信，需要创建两条管道，管道1：父进程写，子进程读；管道2：子进程写，父进程读
2.管道的本质是文件，因为 fd 的生命周期随进程而终止，所以管道的生命周期也是随着进程而结束的
- 当进程终止运行时，管道资源会被 OS 回收
3.匿名管道常用来进行具有 “血缘” 关系的进程，进行进程间通信（常用于父子进程间通信）
- pipe 打开管道，并不清楚管道的名字等信息，这种管道称为 匿名管道，因此 匿名管道 只能用于有血缘关系的进程 IPC，因为 需要通过 fork 继承匿名管道信息
4.在管道中，写入 与 读取 的次数并不是严格匹配的，此时读写次数没有强相关关系，管道是面向字节流读写的
- 面向字节流读写又称为 流式服务：数据没有明确的分割，不分一定的报文段；与之相对应的是 数据报服务：数据有明确的分割，拿数据按报文段拿
不论写端写入了多少数据，只要写端停止写入，读端都可以将数据读取
5.具有一定的协同能力，让 读端 和 写端 能够按照一定的步骤进行通信（自带同步机制）
- 当读端进行从管道中读取数据时，如果没有数据，则会阻塞，等待写端写入数据；如果读端正在读取，那么写端将会阻塞等待读端，因此 管道自带 同步与互斥 机制
2.5应用场景
2.5.1场景一
父进程不写，此时管道为空，子进程尝试读取
伪代码段
// 父进程不写（空），子进程读
//子进程（尝试读取）
int cnt = 1;
while (true)
{
char ch;
read(pipefd[0], &ch, 1);
cout << "已读取 " << cnt++ << " 字节的数据" << endl;
}
//父进程（不写）
while (true) {}
结果：因为管道为空，因此子进程无法读取，即 读端阻塞
只有当写端写入数据后，读端才能正常读取
2.5.2场景二
父进程不断写入，直到管道写满，子进程不读取
伪代码段
//父进程写（满），子进程不读
//子进程（不读）
while (true) {}
//父进程（不断写入）
int cnt = 1; // 计数器
while (true)
{
char ch = 'x';
write(pipefd[1], &ch, 1); // 写入数据
cout << "已写入 " << cnt++ << " 字节的数据" << endl;
}
结果：在一段时间后，管道被写满，写端无法写入数据，进入阻塞状态
只有当读端尝试将管道中的数据读走一部分后，写端才能继续写入
2.5.3场景三
通信的过程中，关闭写端，只保留读端
伪代码段
//写端写入一段信息后，就关闭
//子进程正常读取，并且对读取到的数据量进行判断
char buff[64];
while(true)
{
int n = read(pipefd[0], buff, sizeof(buff) - 1);
buff[n] = '\0';
if(n == 0)
cout << "写端已关闭，读取数据量为: " << n << " 字节" << endl;
else
cout << "成功读取到信息: " << buff << endl;
sleep(1);
}
//父进程只写入一次数据，然后关闭写端
char buff[] = "Hello pipe!";
write(pipefd[1], buff, strlen(buff)); // 写入数据
close(pipefd[1]); // 关闭剩下的写端
结果：关闭写端后，读端会将匿名管道中的数据读取完后，再读，会读到 0，表示已读到文件末尾
如何理解？
- 因为管道是单流向通信，写端都关闭了，证明不会再有数据写入，因此当读端把剩余数据都读取后，每次都是读取
0字节数据，表明此时已经读到了结尾，读端也可以结束读取了
2.5.4场景四
在通信过程中，关闭读端，只保留写端
注：这里将角色变换一下，方便父进程捕捉到子进程的退出信号
切换：父进程 -> 读端，子进程 -> 写端
伪代码段
//读端读取一段时间后，就关闭
//子进程不断写入
while (true)
{
char buff[] = "Hello pipe!";
write(pipefd[1], buff, strlen(buff)); // 写入数据
sleep(1);
}
//父进程在读取五次信息后，就终止读取，关闭读端
char buff[64];
int cnt = 1;
while (true)
{
int n = read(pipefd[0], buff, sizeof(buff) - 1);
buff[n] = '\0';
if (n == 0)
cout << "写端已关闭，读取数据量为: " << n << " 字节" << endl;
else
cout << "成功读取到信息: " << buff << endl;
// 读取五次后，关闭读端
if (cnt++ == 5)
break;
}
close(pipefd[0]);
// 父进程等待子进程结束
int status = 0;
waitpid(id, &status, 0);
printf("子进程异常退出，core dump: %d 退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
结果：OS 不允许任何浪费资源的行为存在，如果关闭了读端，那么证明写端写了也没有，即没有存在的意义，于是 OS 会发出 13 号信号，终止写端进程
以上就是管道的四种特殊场景，不仅适用于匿名管道，同时也适用于命名管道
2.6匿名管道的大小
既然管道能被写满，那么管道的大小究竟是多少？
man 7 pipe
接着输入 /pipe capacity 即可搜索出管道的大小
3.进程池-进程控制
场景：父进程创建了一批子进程，并通过多条匿名管道与它们链接，父进程选择某个子进程，并通过匿名管道与子进程通信，并下达指定的任务让其执行
3.1逻辑设计
3.2具体功能实现
1、创建一批进程及管道
创建一批进程及管道
首先需要先创建一个包含进程信息的类，最主要的就是子进程的写端 fd，这样父进程才能通过此 fd 进行数据写入
循环创建管道、子进程，进行相应的管道链接操作，然后子进程进入任务等待状态，父进程将创建好的子进程信息注册
假设子进程获取了任务代号，那么应该根据任务代号，去执行相应的任务，否则阻塞等待
注意： 因为是创建子进程，所以存在关系重复继承的情况，此时应该统计当前子进程的写端 fd，在创建下一个进程时，关闭无关的 fd
具体体现为：每次都把 写端 fd 存储起来，在确定关系前 “清理” 干净
#define NAME_SIZE 64
// 封装一个包含各种必备信息的类
class ProcInfo
{
public:
ProcInfo(pid_t id = pid_t(), int fd = int())
: _childID(id), _wfd(fd), _num(++_count)
{
char buff[NAME_SIZE];
snprintf(buff, sizeof buff, "Process %d [%d:%d]", _num, _childID, _wfd);
_name = string(buff);
}
~ProcInfo()
{
_childID = _wfd = 0;
}
pid_t _childID; // pid
int _wfd; // 写端 fd
string _name; // 进程名
int _num; //编号
static int _count; // 计数
};
int ProcInfo::_count = 0; // 静态成员初始化
void CreateProcessAndPipe(vector<ProcInfo> &PP, int ppNum = 3)
{
vector<int> fds; //存储继承中不需要的写端 fd
for(int i = 0; i < ppNum; i++)
{
//首先创建管道
int pipefd[2];
int ret = pipe(pipefd);
assert(ret != -1);
(void)ret;
//然后创建子进程
int id = fork();
assert(id != -1);
(void)id;
if(id == 0)
{
//子进程内
//需要先关闭之前子进程遗留的写端fd
for(auto e : fds)
close(e);
close(pipefd[1]); //子进程关闭写端
waitCommand(pipefd[0]); //子进程等待命令
close(pipefd[0]);
exit(0);
}
//父进程内
close(pipefd[0]); //父进程关闭读端
PP.push_back(ProcInfo(id, pipefd[1]));
fds.push_back(pipefd[1]);
}
}
3.3任务类创建及任务等待
子进程在创建完成后，需要进入一个 等待阶段 -> 读端阻塞，同时当子进程读取到相应的 指令 时，需要执行相应任务，这里将封装成了一个类，并通过对象调用函数
ctrlProc.cc中
void waitCommand(int rfd)
{
while(true)
{
//读端尝试读取信息
int command = 0;
int n = read(rfd, &command, sizeof(command));
if(n != 0)
{
TaskPools().Execute(command);
}
else
{
cout << "当前子进程读取任务失败，已退出!" << endl;
break;
}
}
}
Task.hpp中
#pragma once
#include <iostream>
#include <vector>
#include <unistd.h>
using namespace std;
void PrintLOG()
{
cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}
void InsertSQL()
{
cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}
void NetRequst()
{
cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}
typedef void(*func_t)();
//任务池
class TaskPools
{
public:
TaskPools()
{
//装载任务
_vft.push_back(PrintLOG);
_vft.push_back(InsertSQL);
_vft.push_back(NetRequst);
}
~TaskPools()
{}
void Execute(int num)
{
//根据编号，执行任务
if(num < 0 || num > _vft.size())
cout << "没有这个任务" << endl;
else
_vft[num]();
}
private:
vector<func_t> _vft; //可用任务表
};
3.4子进程控制
当所有子进程都完成注册后（统计至 PP 中），可以让用户输入下标选择程序、输入任务编号选择任务、或者输入程序退出
注意： 因为当前子进程编号从 1 开始，所以在进行下标访问时，需要 -1 避免越界
void showTask()
{
cout << "**************************" << endl;
cout << "* 0.日志打印 1.数据插入 *" << endl;
cout << "* 2.网络请求 3.退出程序 *" << endl;
cout << "**************************" << endl;
}
void CtrlProcess(vector<ProcInfo> &PP)
{
while (true)
{
// 展示当前可用的进程
int index = 0;
do
{
cout << "当前可选择进程：";
for (int i = 1; i <= PP.size(); i++)
cout << i << " ";
cout << endl;
cout << "请选择进程: ";
cin >> index;
} while (index < 1 || index > PP.size());
int taskNum = 0;
do
{
showTask(); // 展示可选任务
cout << "请选择任务: ";
cin >> taskNum;
} while (taskNum < 0 || taskNum > 3);
// 分配任务
if(taskNum == 3)
break;
cout << "已选择： " << PP[index - 1]._num << " 号进程 | " << PP[index - 1]._name << endl;
write(PP[index - 1]._wfd, &taskNum, sizeof(taskNum));
sleep(1); //执行完任务后，睡一会
}
}
3.5子进程回收
子进程回收十分简单，因为已经在 PP 中存储了各个子进程的 PID，只需要遍历等待回收即可
void WaitProcess(vector<ProcInfo> &PP)
{
// 遍历回收就好了
for (auto e : PP)
{
close(e._wfd); //关闭写端，读端读取到 0 自动结束阻塞
int status = 0;
waitpid(e._childID, &status, 0);
// 通过 status 判断子进程运行情况
if ((status & 0x7F))
{
printf("子进程异常退出，core dump: %d 退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
}
else
{
printf("子进程 %s 正常退出，退出码：%d\n", e._name.c_str(), (status >> 8) & 0xFF);
}
}
cout << "所有子进程都已回收" << endl;
}
3.6注意事项
总体来说，在使用这个小程序时，以下关键点还是值得多注意的
- 注册子进程信息时，存储的是 写端 fd，目的是为了通过此 fd 向对应的子进程写数据，即使用不同的匿名管道
- 创建管道后，需要关闭父、子进程中不必要的 fd
- 需要特别注意父进程写端 fd 被多次继承的问题，避免因写端没有关干净，而导致读端持续阻塞
- 关闭读端对应的写端后，读端会读到 0，可以借助此特性结束子进程的运行
- 在选择进程 / 任务 时，要做好越界检查
- 等待子进程退出时，需要先关闭写端，子进程才会退出，然后才能正常等待
3.7完整代码
ctrlProc.cc
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp" //任务所需头文件
using namespace std;
#define NAME_SIZE 64
// 封装一个包含各种必备信息的类
class ProcInfo
{
public:
ProcInfo(pid_t id = pid_t(), int fd = int())
: _childID(id), _wfd(fd), _num(++_count)
{
char buff[NAME_SIZE];
snprintf(buff, sizeof buff, "Process %d [%d:%d]", _num, _childID, _wfd);
_name = string(buff);
}
~ProcInfo()
{
_childID = _wfd = 0;
}
pid_t _childID; // pid
int _wfd; // 写端 fd
string _name; // 进程名
int _num; // 编号
static int _count; // 计数
};
int ProcInfo::_count = 0; // 静态成员初始化
void waitCommand(int rfd)
{
while (true)
{
// 读端尝试读取信息
int command = 0;
int n = read(rfd, &command, sizeof(command));
if (n != 0)
{
TaskPools().Execute(command);
}
else
{
cout << "当前子进程读取任务失败，已退出!" << endl;
break;
}
}
}
void CreateProcessAndPipe(vector<ProcInfo> &PP, int ppNum = 3)
{
vector<int> fds; // 存储继承中不需要的写端 fd
for (int i = 0; i < ppNum; i++)
{
// 首先创建管道
int pipefd[2];
int ret = pipe(pipefd);
assert(ret != -1);
(void)ret;
// 然后创建子进程
int id = fork();
assert(id != -1);
(void)id;
if (id == 0)
{
// 子进程内
// 需要先关闭之前子进程遗留的写端fd
for (auto e : fds)
close(e);
close(pipefd[1]); // 子进程关闭写端
waitCommand(pipefd[0]); // 子进程等待命令
close(pipefd[0]);
exit(0);
}
// 父进程内
close(pipefd[0]); // 父进程关闭读端
PP.push_back(ProcInfo(id, pipefd[1]));
fds.push_back(pipefd[1]);
}
}
void showTask()
{
cout << "**************************" << endl;
cout << "* 0.日志打印 1.数据插入 *" << endl;
cout << "* 2.网络请求 3.退出程序 *" << endl;
cout << "**************************" << endl;
}
void CtrlProcess(vector<ProcInfo> &PP)
{
while (true)
{
// 展示当前可用的进程
int index = 0;
do
{
cout << "当前可选择进程：";
for (int i = 1; i <= PP.size(); i++)
cout << i << " ";
cout << endl;
cout << "请选择进程: ";
cin >> index;
} while (index < 1 || index > PP.size());
int taskNum = 0;
do
{
showTask(); // 展示可选任务
cout << "请选择任务: ";
cin >> taskNum;
} while (taskNum < 0 || taskNum > 3);
// 分配任务
if (taskNum == 3)
break;
cout << "已选择： " << PP[index - 1]._num << " 号进程 | " << PP[index - 1]._name << endl;
write(PP[index - 1]._wfd, &taskNum, sizeof(taskNum));
sleep(1); // 执行完任务后，睡一会
}
}
void WaitProcess(vector<ProcInfo> &PP)
{
// 遍历回收就好了
for (auto e : PP)
{
close(e._wfd); //关闭写端，读端读取到 0 自动结束阻塞
int status = 0;
waitpid(e._childID, &status, 0);
// 通过 status 判断子进程运行情况
if ((status & 0x7F))
{
printf("子进程异常退出，core dump: %d 退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
}
else
{
printf("子进程 %s 正常退出，退出码：%d\n", e._name.c_str(), (status >> 8) & 0xFF);
}
}
cout << "所有子进程都已回收" << endl;
}
int main()
{
// 1、创建一批进程及匿名管道
vector<ProcInfo> PP;
CreateProcessAndPipe(PP);
// 2、进程控制
CtrlProcess(PP);
// 3、进程回收
WaitProcess(PP);
return 0;
}
Task.hpp
#pragma once
#include <iostream>
#include <vector>
#include <unistd.h>
using namespace std;
void PrintLOG()
{
cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}
void InsertSQL()
{
cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}
void NetRequst()
{
cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}
typedef void(*func_t)();
//任务池
class TaskPools
{
public:
TaskPools()
{
_vft.push_back(PrintLOG);
_vft.push_back(InsertSQL);
_vft.push_back(NetRequst);
}
~TaskPools()
{}
void Execute(int num)
{
//根据编号，执行任务
if(num < 0 || num > _vft.size())
cout << "没有这个任务" << endl;
else
_vft[num]();
}
private:
vector<func_t> _vft; //可用任务表
};
Makefile
ctrlProc:ctrlProc.cc
g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
rm -r ctrlProc
扫一扫
1039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
