Linux——进程间通信1
目录
进程间通信目的
进程间通信标准
管道
匿名管道
管道实现进程间通信
管道的特点
进程池
ProcessPool.cc
Task.hpp
习题
进程间通信目的
数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变
进程间通信不是目的，是手段。
技术背景
1.进程是具有独立性的，虚拟地址空间+页表保证进程允许的独立性（进程内核数据结构+进程的代码和数据）
2.通信成本会比较高
进程间通信的本质理解
1.进程间通信的前提，首先需要让不同的进程看到同一块“内存”（特定的结构组织的）
2.这个所谓的“内存”不属于任何一个进程，强调的是共享
进程间通信标准
1.Linux原生能提供——管道（匿名，命名）
2.SystemV——多进程——单机通信
SystemV有共享内存，消息队列，信号量
3.posix——多线程——网络通信
这些标准在使用者看来，都是接口上具有一定的规律。
管道
管道是Unix中最古老的进程间通信的形式。
我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”
只要是管道就一定有出口和入口，但是出入口数量有n种可能，单向传输内容，管道是用来传资源的。计算机的设计者，设计了一种单向通信模式——管道。
管道通信背后是进程之间通过管道进行通信
每个进程都有一个自己的文件描述符表，进程内部有files*指针，指向自己的文件描述符表，文件描述符表都有自己的数组下标，0，1，2是标准输入，标准输出，标准错误流，linux下一切皆文件，没个文件都有自己的struct_file结构，struct_file不仅包含inode属性，也包含文件对应的内核缓冲区，这个缓冲区在内核中对应的结构叫address_space
1. 我们以读和写的方式打开同一个文件，给父进程返回的时候会返回俩个文件描述符
2.fork（）创建子进程
由于进程具有独立性，子进程会有自己的task_struct和文件描述符表，之后父进程相关的数据会拷贝给子进程，文件描述符表也会拷贝给子进程。
这样不同的进程看到同一份资源（内存），这里这是创建了子进程，我们的目的是子进程，不会拷贝文件相关数据结构，只会拷贝进程相关数据结构。
管道的底层原理就是以文件的形式设计
3.双方进程各自关闭自己不需要的文件描述符。
由于管道是单向通信，我们目前规定父进程写入，子进程读取。
这就叫管道 ，管道就是文件，俩个进程通过文件来进行通信
当我们在上面操作的文件中写入了数据，没必要把这些数据刷新到磁盘中，进程间通信要保证纯内存级别的通信，磁盘是外设。
匿名管道
#include
功能:创建一无名管道
原型
int pipe(int fd[2]);
输出型参数，期望通过调用它，得到被打开的文件fd，创建成功时返回值为0，失败返回值为-1。
谁调用pipe，就让谁以读写方式打开文件，不需要指定文件名，这个文件是纯内存级别的，如struct_file就不在磁盘中。文件属于内核，一个进程把文件给操作系统，然后另一个进程通过操作系统去读取。
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码
用代码进行测试
进行调试
如果要不想调试
在-DDEBUG前面加#
此时结果不能打印
我们接下来要实现让父进程写入，子进程读取。
创建子进程，并进行读写通道的建立
read的返回值类型是ssize_t这是long int
snprintf，把特定的字符串内容显示到字符串中
管道实现进程间通信
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
int main()
{
int pipefd[2]={0};//默认设置为0
int n=pipe(pipefd);//完成了管道的创建,默认以读写方式打开
//断言在DEBUG模式下有效，release无效
//如果没有(void)n n就只被定义而未被使用，可能会在 Realse模式下会出现大量的警告，所以我们加了(void)n
assert(n!=-1);
(void)n;
//查看读和写对应的文件描述符
#ifdef DEBUG
cout << "pipefd[0]: " << pipefd[0] << endl; // 3 读端
cout << "pipefd[1]: " << pipefd[1] << endl; // 4 写端
#endif
//2.创建子进程
pid_t id=fork();
assert(id!=-1);
if(id==0)
{
//子进程
//3.构建单向通信的信道
// 3.1关闭子进程不需要的fd
close(pipefd[1]);//子进程关闭写端
char buffer[1024];
while(true)
{
ssize_t s= read(pipefd[0],buffer,sizeof(buffer)-1);//从读端进行读，将内容读取到buffer中，大小为buffer-1
if(s>0)//读取成功
{
buffer[s]=0;//由于是系统层面的读取，没有\0，所以我们在这添加\0
cout<<"child get a message["< 
我们在程序里写端缓冲区有一个buffer，读端缓冲区也有一个buffer， 不用全局buffer是因为有写时拷贝的存在，父子进程要确保自己数据的私有性，再怎么定义全局变量，也无法进行通信。
管道的特点
1.管道是用来进行具有“学院”关系的进程进行进程间通信——常用于父子通信
管道是一个文件，显示器也是一个文件，父子同时往显示器写入的时候，如果没有先后顺序俩个同时写入，这种情况是由于缺乏访问控制。
管道文件，在进行读取的时候，子进程会等待父进程，如这里休眠10s，在休眠的这段时间，子进程一直都在等父进程，所以显示器未打印数据，这叫具有访问控制
2.管道具有通过让进程间协同，提供了访问控制
不控制父进程的写入速度，让子子进程20s后再读
程序一执行，管道就被写满
之后子进程进行读取，一次性把管道里的内容读取完
子进程读取完之后，父进程又开始写，直到写满
3.管道提供的时面向流式的服务——面向字节流一般需要定制协议
4.管道是基于文件的，文件的生命周期时随进程的，管道的生命周期是随进程的（如果父子进程在使用管道通信，通信双方退出，管道会被自动释放）
如果读的时候，写入的一方的fd没有关闭，如果有数据就读，没有数据就等，如果写入的一方fd关闭，读取的一方，read会返回0，表示读到了文件的结尾
写了10次，关闭写端
写入端关闭，子进程 退出
5.管道是单向通信的，就是半双工通信的一种特殊情况（要么一者在接收，要么一者在发送）。 全双工（俩人吵架，俩人同时在说，同时在听）。
a.写快，读慢，写满就不能再写了
b.写慢，读快，管道没有数据的时候，就必须等待
c.写关，读到了0（读到文件结尾，即把所有文件读取完），表示读到了文件结尾
d.读关，写继续写，OS终止写进程
当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性（只有做和不做俩种选择）。
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。
进程池
每个子进程和父进程形成一个管道，0是fd为0，1是fd为1，当用户要父进程完成任务时，父进程可指派子进程进行完成，可随机选子进程或按照某种特定顺序让子进程执行。
我们在这里让父进程每次写4字节，子进程读四字节
ProcessPool.cc
#include
#include
#include
#include
#include
#include
#include
#include
#include "Task.hpp"
#define PROCESS_NUM 5//进程个数
using namespace std;
int waitCommand(int waitFd,bool &quit)
{
//uint32_t是4个字节
uint32_t command=0;
ssize_t s=read(waitFd,&command,sizeof(command));//从waitFd里读取内容到command，大小为4个字节
if(s==0)//此时把文件描述符关了
{
quit=true;
return -1;
}
assert(s==sizeof(uint32_t));
return command;//返回读到的命令
}
void sendAndWakeup(pid_t who, int fd, uint32_t command)
{
//给who进程通过fd发送command命令
write(fd, &command, sizeof(command));
cout << "main process: call process " << who << " execute " << desc[command] << " through " << fd << endl;
}
int main()
{
load();
vector> slots;//pair的first是pid,second是进程相关信息pipefd
//slots是一个表，表里存的是子进程的id和pipefd，父进程可以通过该表选择让哪个子进程执行任务
//创建多个进程
for(int i=0;i=0&&command(id,pipefd[1]));//子进程ID，写端描述符
//把所有的子进程信息，放到vector里，形成一张子进程表
}
//整个for循环就是在选择父进程在选择子进程，并且准备给子进程发指令
//父进程派发任务,用单机版的负载均衡（防止出现一个子进程做多个任务，均衡一下子进程工作量）
//我们用随机数派发
srand((unsigned long)time(nullptr)^getpid()^2323232323L);//让数据源更随机
while(true)
{
cout<<"########################################"<>select;
if(select==1)//显示可以被执行的任务
{
showHandler();
}
else if(select==2)//发送命令
{
//选择任务
cout<<"Enter Your Command";
cin>>command;//输入命令
//选择进程
int choice=rand()%slots.size();
//布置任务,把任务给指定的进程
sendAndWakeup(slots[choice].first,slots[choice].second,command);//发送命令并且唤醒子进程
}
else
{}
}
//关闭fd,结束所有进程
for(const auto slot:slots)
{
close(slot.second);
}
//回收所有的子进程信息
for(const auto slot:slots)
{
waitpid(slot.first,nullptr,0);
}
return 0;
} Task.hpp
#pragma once
#include
#include
#include
#include
#include
#include
typedef std::function func;//定义一个函数类型，返回值类型void，参数()
std::vector callbacks;//回调
std::unordered_map desc;
void readMySQL()
{
std::cout << "sub process[" << getpid() << " ] 执行访问数据库的任务\n" << std::endl;
}
void execuleUrl()
{
std::cout << "sub process[" << getpid() << " ] 执行url解析\n" << std::endl;
}
void cal()
{
std::cout << "sub process[" << getpid() << " ] 执行加密任务\n" << std::endl;
}
void save()
{
std::cout << "sub process[" << getpid() << " ] 执行数据持久化任务\n" << std::endl;
}
void load()
{
desc.insert({callbacks.size(), "readMySQL: 读取数据库"});//相当于构建键值对，0号命令对应readmysql
callbacks.push_back(readMySQL);//下标为0，插入ReadMysql
desc.insert({callbacks.size(), "execuleUrl: 进行url解析"});
callbacks.push_back(execuleUrl);
desc.insert({callbacks.size(), "cal: 进行加密计算"});
callbacks.push_back(cal);
desc.insert({callbacks.size(), "save: 进行数据的文件保存"});
callbacks.push_back(save);
}
void showHandler()//显示当前所有的方法
{
for(const auto &iter : desc )
{
std::cout << iter.first << "\t" << iter.second << std::endl;
}
}
int handlerSize()//共有多少任务的处理方法
{
return callbacks.size();
} 习题
1.以下描述正确的有：B
A.进程之间可以直接通过地址访问进行相互通信
B.进程之间不可以直接通过地址访问进行相互通信
C.所有的进程间通信都是通过内核中的缓冲区实现的
D.以上都是错误的
A错误： 进程之间具有独立性，拥有自己的虚拟地址空间，因此无法通过各自的虚拟地址进行通信（A的地址经过B的页表映射不一定映射在什么位置）
B正确
C错误： 除了内核中的缓冲区之外还有文件以及网络通信的方式可以实现
2.以下选项属于进程间通信的是（A,B,D）[多选]
A.管道
B.套接字
C.内存
D.消息队列
典型进程间通信方式：管道，共享内存，消息队列，信号量。 除此之外还有网络通信，以及文件等多种方式
C选项，这里的内存太过宽泛，并没有特指某种技术，错误。
3.下列关于管道(Pipe)通信的叙述中，正确的是(C)
A.一个管道可以实现双向数据传输
B.管道的容量仅受磁盘容量大小限制
C.进程对管道进行读操作和写操作都可能被阻塞
D.一个管道只能有一个读进程或一个写进程对其操作
A错误 管道是半双工通信，是可以选择方向的单向通信
B错误 管道的本质是内核中的缓冲区，通过内核缓冲区实现通信，命名管道的文件虽然可见于文件系统，但是只是标识符，并非通信介质
C正确 管道自带同步（没有数据读阻塞，缓冲区写满写阻塞）与互斥
D错误 多个进程只要能够访问同一管道就可以实现通信，不限于读写个数
4.以下关于管道的描述中，正确的是 [多选]B,D
A错误，匿名管道只能用于具有亲缘关系的进程间通信，命名管道可以用于同一主机上的任意进程间通信
B正确
C错误，匿名管道需要在创建子进程之前创建，因为只有这样才能复制到管道的操作句柄，与具有亲缘关系的进程实现访问同一个管道通信
D正确
5.以下关于管道的描述中错误的是 [多选]B,C
A.可以通过int pipe(int pipefd[2])接口创建匿名管道，其中pipefd[0]用于从管道中读取数据
B.可以通过int pipe(int pipefd[2])接口创建匿名管道，其中pipefd[0]用于向管道中写入数据
C.若在所有进程中将管道的写端关闭，则从管道中读取数据时会返回-1；
D.管道的本质是内核中的一块缓冲区；
- 管道本质是内核中的一块缓冲区，多个进程通过访问同一块缓冲区实现通信。
- 使用int pipe(int pipefd[2])接口创建匿名管道，pipefd[0]用于从管道读取数据，pipefd[1]用于向管道写入数据。
- 管道特性：半双工通信，自带同步与互斥，生命周期随进程，提供字节流传输服务。
- 在同步的提现中，若管道所有写段关闭，则从管道中读取完所有数据后，继续read会返回0，不再阻塞；若所有读端关闭，则继续write写入会触发异常导致进程退出
根据以上管道理解分析：A正确，B错误，C错误，D正确
因为题目为选择错误选项，因此选择B和C选项