一、是什么
两个或者多个进程实现数据层面的交互
因为进程独立性的存在,导致进程通信的成本比较高
通信是有成本的,体现在要打破进程独立性
二、为什么
- 基本数据
- 发送命令
- 实现某种协同
- 通知
- …
最终都是要通信起来
三、怎么办
进程间通信的本质:必须让不同的进程看到同一份“资源”
“资源”:特定形式的内存空间
这个”资源“谁提供?一般是操作系统,为什么不是我们两个进程中的一个呢?假设是由一个进程提供的,那么这个资源属于谁?属于这个进程独有。这样会破坏进程独立性。所以由操作系统也就是第三方空间提供。
所以我们进程访问这个空间,进行通信,本质就是访问操作系统!
进程代表的就是用户。”资源“从创建,使用,释放,都是有系统调用接口的!!
所以从底层设计,从接口设计,都要由操作系统独立设计
一般操作系统会有一个独立的通信模块----隶属于文件系统 -----IPC(进程间通信)通信模块
需要定制标准 ---- 进程间通信是有标准的 ----- system V && posix
system V用于本机内部通信,而posix用于网络的通信
system V的通信方式有如下:消息队列,共享内存,信号量
posix的通信方式有:消息队列,共享内存,信号量,互斥量,条件变量,读写锁
- 还有一种方式是基于文件级别的通信方式 ---- 管道
四、管道
1.什么是管道
如果一个文件被可以多个进程打开,那么这个文件就可以作为公共资源,一个读,一个写即可
所谓的管道就是类似的基于文件级别的通信方式
管道是Unix中最古老的进程间通信的形式。
我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”
如下所示,我们知道这样的竖划线其实也是管道
其实就是who进程的数据写到了管道里面,然后wc进程的数据需要从管道支中读取
2.管道的原理
如下图所示,当我们启动了一个进程以后,自然而然就要创建test_strcut对象,然后这里面会有一个指针指向文件描述符表,在这个表中会有一个指针数组,它的下标就是文件描述符,其中0,1,2号文件描述符要被默认打开的标准输入,标准输出,标准错误三个流所占用,值得注意的是,显示器本来只有一个,但是我们这里为了方便,画成了两个
然后当我们未来新打开一个文件以后,就会创建一个新的struct file,并将最小的没有被使用的下标作为这个的文件描述符,然后会返回这个文件描述符
然后在这个struct file中,有inode用于寻找文件属性,有file_operators用于实现一切皆文件,还有一个缓冲区
在磁盘中,也会在特定的分区特定的分组有对应的数据块和属性块,供我们读写,如果写的时候,一旦对应的位置为脏,那么就会往回刷新过去,从而进行写入。
(即打开文件的时候,因为struct file本身就会创建一个struct inode,这个inode里面就是文件的属性,供我们查看,这个inode里面的会直接从磁盘当中的inode里面加载。缓冲区则是磁盘当中的数据要先加载到这个缓冲区中,当我们利用file_operators的方法去修改缓冲区以后,就是数据为脏了,然后就会将这个数据刷新回磁盘)
而现在,我们让创建的这个文件在磁盘当中并不存在,但是有对应的inode,file_operators,缓冲区。
即只要有左半边的功能即可,这样他就是一个内存级别的文件
而现在,当我们这个进程在创建子进程的时候,它肯定会创建一个PCB,然后对应的文件描述符表也会拷贝一份。这两份文件描述符表的内容是一模一样的,左边的都是属于进程的,而右边的是属于文件的,不需要拷贝也不会拷贝。
正是由于这两个文件描述符表一模一样,所以才导致了我们父子进程会在同一个文件中打印。
而上面的这个过程,最终会导致,我们新开的这个文件也会被两个进程都指向
而我们前面所说的进程间通信,本质前提是需要先让不同的进程,看到同一份资源!!
这样我们就可以利用这个文件实现进程间通信了!
这就是管道的一个比较朴素的原理
所以管道其实就是文件
而且在这里会由于有引用计数,即便父进程关闭了这个文件,也不会消失的
在这里如果我们父进程只有只读方式打开,那么这个文件描述符表继承下来的时候也是只读方式,这就没法通信了。所以其实父进程在打开文件的时候,会把文件以读写方式都打开一遍。这样的话就是下面的原理了!
如下图所示,当我们的task_struct要将同一个文件分别以读写的方式打开的时候,会分别创建对应的struct file,只不过他们里面的inode,文件缓冲区,等等都是一样的,只是权限不同。
然后我们继续创建子进程就是如下所示
像上面的这种,我们只想用来实现单向通信的
假设现在,我们想让子进程进行写入,父进程进行读取
当我们想要子进程写入,父进程读取的时候,只需要关闭对应的读写端即可
此时,两个struct file的引用计数都会变为1,也不可能会再次产生影响
这就是管道的原理
正式因为这个只能进行单向通信,所以才将它称作管道
那么如果要双向通信呢?
我们可以创建多个管道,比如两个管道就可以了
那么这两个进程如果没有任何关系,可以用我们上面的原理进行通信吗?
不能。必须是父子关系,兄弟关系,爷孙关系…
总之必须是具有血缘关系的进程,只不过常用于父子
那么我们这个文件有名字,路径…吗?即下面这部分
答案是没有的,它根本不需要名字,更不需要怎么标定它,因为它是通过继承父进程的资源来得到的。
所以我们把这种管道的名字叫做匿名管道
当然至此我们还没有通信,我们前面所做的工作都是建立通信信道,那么为什么这么费劲呢?这是因为进程具有独立性,通信是有成本的
3.接口
int pipe(int pipefd[2])
上面这个系统调用,它的作用就是创建一个管道
如果成功的话,返回0,如果错误,返回-1,并且错误码errno被设置
那么它的参数是什么意思呢?
这个参数其实是一个输出型参数
也就是说,调用这个pipe以后,父进程就会以读写方式打开一个内存级文件了
打开以后,它的工作就完了
所以这个参数的意思就是,创建好内存级文件以后,就会把对应的两个文件描述符给带出来,供用户使用!!!
其中,一般pipefd[0]是读下标,pipefd[1]是写下标
4.编码实现
在如下代码中运行结果为
#include <iostream>
#include <unistd.h>
#define N 2
using namespace std;
int main()
{
int pipefd[N] = {0};
int n = pipe(pipefd);
if(n < 0) return 1;
std::cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << std::endl;
return 0;
}
如下代码是一个简单的实现管道间的通信
#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstring>
#define N 2
#define NUM 1024
using namespace std;
void Writer(int wfd)
{
string s = "hello I am child";
pid_t self = getpid();
int number = 0;
char buffer[NUM];
while(1)
{
//构建发送字符串
buffer[0] = 0;
snprintf(buffer, sizeof(buffer), "%s-%d-%d", s.c_str(), self, number++);
//cout << buffer;
//发送给父进程
write(wfd, buffer, strlen(buffer));
sleep(1);
}
}
void Reader(int rfd)
{
char buffer[NUM];
while(1)
{
buffer[0] = 0;
ssize_t n = read(rfd, buffer, sizeof(buffer));
if(n > 0)
{
buffer[n] = 0;
cout << "father get a message : ["<<buffer << "]" << endl;
}
}
}
int main()
{
int pipefd[N] = {0};
int n = pipe(pipefd);
if(n < 0) return 1;
// std::cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << std::endl;
pid_t id = fork();
if(id < 0)
{
return 2;
}
else if(id == 0)
{
//child
close(pipefd[0]);
Writer(pipefd[1]);
close(pipefd[1]);
exit(0);
}
//father
close(pipefd[1]);
Reader(pipefd[0]);
pid_t rid = waitpid(id, NULL, 0);
if(rid < 0) return 3;
close(pipefd[0]);
return 0;
}
5.管道的特征
具有血缘关系的进程进行进程间通信
管道只能单向通信
父子进程是会协同的,同步与互斥的,是为了保护管道文件的数据安全
因为该资源是不同的多执行流共享的,难免会出现访问冲突的问题,这也就是临界资源竞争的问题
如下所示,父子进程并没有出现,子进程执行一条,而父进程执行很多条的情况,虽然父进程中并没有每隔一秒打印一次的代码,但是会跟子进程写入的速度差不多。
管道是面向字节流的
管道是基于文件的,而文件的生命周期是随进程的!
6.管道的四种情况
读写端正常,管道如果为空,读端就要阻塞
读写端正常,管道如果被写满,写端就要被阻塞
从这里也能得到,管道是有固定大小的
我们可以先用下面这个命令观察一下,这个命令的功能是查看一些数据的最大限制
ulimit -a
在这里我们可以看到,管道一共有512 * 8 == 4KB大小
那么我们可以来测试一下是不是这么大呢?
我们让写端的代码为如下,读端不去读。
运行结果为如下,65535
即一共有64KB。
那我们前面的4KB是什么呢?
其实管道的大小在不同的内核中是不同的。
当前我们系统的管道大小是64KB
现在回答前面的4KB究竟是什么,这是因为我们写端在写入数据以后,读端要读数据,但是不能写了一半就读走了,这样可能导致数据出现问题。所以要么就不读,要么一次全读完, 也就是PIPE_BUF就是要保证是一个原子性的最大长度。不能被打断的,而这个PIPE_BUF就是4KB,也就是前面查到的4KB。
- 读端正常读,写端关闭,读端就会读到0,表明读到了文件(pipe)结尾,不会被阻塞
运行结果为
前五秒正常读取,后面直接输出0
所以这个代码应该改为
运行结果为
- 写端正常写入,读端关闭了。操作系统就要杀掉正在写入的进程
因为操作系统是不会去做,低效,浪费等类似的工作的,如果做了,就是操作系统的bug
那么如果干掉这个进程呢?通过信号杀掉
而我们前面的这个样例就是子进程写入,父进程读取。我们可以用如下代码来做一个小实验
#include <iostream> #include <unistd.h> #include <cstdlib> #include <cstdio> #include <string> #include <sys/types.h> #include <sys/wait.h> #include <cstring> #define N 2 #define NUM 1024 using namespace std; void Writer(int wfd) { string s = "hello I am child"; pid_t self = getpid(); int number = 0; char buffer[NUM]; while(1) { //构建发送字符串 buffer[0] = 0; snprintf(buffer, sizeof(buffer), "%s-%d-%d", s.c_str(), self, number++); //cout << buffer; //发送给父进程 write(wfd, buffer, strlen(buffer)); sleep(1); // sleep(1); // char c = 'c'; // write(wfd, &c, 1); // cout << number++ <<endl; // if(number >= 5) break; } } void Reader(int rfd) { char buffer[NUM]; int cnt = 5; while(cnt--) { buffer[0] = 0; ssize_t n = read(rfd, buffer, sizeof(buffer)); if(n > 0) { buffer[n] = 0; cout << "father get a message : ["<<buffer << "]" << endl; } //cout << "n :" << n << endl; else if(n == 0) { cout << "father read file done ...." <<endl; break; } else break; } } int main() { int pipefd[N] = {0}; int n = pipe(pipefd); if(n < 0) return 1; // std::cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << std::endl; pid_t id = fork(); if(id < 0) { return 2; } else if(id == 0) { //child close(pipefd[0]); Writer(pipefd[1]); close(pipefd[1]); exit(0); } //father close(pipefd[1]); Reader(pipefd[0]); close(pipefd[0]); cout << "father close read fd" << pipefd[0] <<endl; sleep(5); // 为了维持一段时间的僵尸 int status = 0; pid_t rid = waitpid(id, &status, 0); if(rid < 0) return 3; cout << "wait child success: " << rid << "exit code: " << ((status>>8)&0xFF) << "exit signal: " << (status&0x7F) <<endl; sleep(5); cout << "father quit" <<endl; return 0; }
最终运行结果为如下
可见与我们上面所说的是一致的
我们也可以注意到,这个子进程退出的原因是13号信号