目录
引言:
1、进程间通信基础介绍
1.1为什么需要在进程之间通信?
1.2进程间通信是什么?
1.3我们具体如何进行进程间的通信呢?
a.一般规律:
b.具体做法
2.管道
2.1什么是管道
2.2匿名管道:
创建方法:pipe函数创建
2.3匿名管道的bug:
3.匿名管道的读写规则
4种情况
5种特性:
在父端写,子端读的情况下子进程的读端为什么都是3?
4.命名管道
4.1.管道的本质
4.2创建一个命名管道
4.3.匿名管道与命名管道的区别
4.4用命名管道实现server&client通信
5.共享内存方式通信:
5.1共享内存如何实现让不同的进程看到同一份资源呢?
5.2.关于共享内存的函数
shmget函数
问题1:这个key是怎么形成的?意义是什么?
问题2:在调用shmget函数时,为什么要让用户传入key值呢?
shmctl函数删除共享内存
shmat函数挂接共享内存
shmdt函数去关联
5.3共享内存的大小
5.4共享内存的原理
5.5.key和shmid到底有什么区别
5.6.共享内存的优缺点
优点:共享内存是所有进程间通信中速度最快的
缺点:
6、信号量
6.1.关于信号量的理论知识
6.2.信号量的原理
在多进程场景下,int全局变量是不能实现计数器的效果呢?
引言:
两个进程之间,可以进行“数据”的直接传送吗?不能!因为进程具有独立性!
进程为什么会有独立性,本质原因是:这两个进程都有自己的虚拟地址空间,但是他们的正文代码,堆,栈,共享区等被映射到了内存当中的不同的物理空间 ,所以在内存方面具有 独立性,不会互相影响
1、进程间通信基础介绍
1.1为什么需要在进程之间通信?
- 数据传输:一个进程需要将它的数据发送给另一个进程
- 资源共享:多个进程之间共享同样的资源。
- 通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止时要通知父进程)。
- 进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。
总结一句话就是,在OS中,往往需要多个进程协同,共同完成一些事情。
1.2进程间通信是什么?
一个进程把自己的数据,能够交给另一个进程。
1.3我们具体如何进行进程间的通信呢?
a.一般规律:
进程间通信的本质:先让不同的进程,看到同一份资源(一般都是要有OS提供)
b.具体做法
OS提供的“空间”有不同的样式,就决定了有不同的通信的方式
- 管道(匿名管道和命名管道)
- 共享内存
- 消息队列
- 信号量
2.管道
2.1什么是管道
这里的子进程并没有将父进程的struct file拷贝下来,由此可见子进程继承父进程的方式是浅拷贝,所以父进程和子进程指向的都是同一份资源!但是子进程会继承父进程的读写段。
因此基于文件的,让不同的进程看到同一份资源的通信方式,叫做管道!管道只能被设计成为单向通信。
为什么父进程最开始,就要将读写两端都开启的形式去打开同一个文件呢?
因为子进程会继承父进程的读写端,而管道的要求就是单向通信,因此父进程就需要将读写段同时打开,等子进程继承之后,会根据要求,各自关掉不用的描述符
2.2匿名管道:
匿名管道:可以(只能)进行具有血缘关系的进程之间进行进程间通信!(常用于父子)
那么匿名管道如何做到让不同的进程看到同一份资源呢?创建子进程,子进程会继承父进程的相关属性信息!
创建方法:pipe函数创建
#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端,这是输出型参数,需要由这两个参数找到匿名管道(匿名文件)
默认fd[0]表示读端,fd[1]表示写端
返回值:成功返回0,失败返回错误代码
下面实现一个父进程读数据,然后通过管道让子进程读。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>void writer(int wfd)
{const char *str = "hello father, I am child";char buffer[128];int cnt = 0;pid_t pid = getpid();while(1){snprintf(buffer, sizeof(buffer), "message: %s, pid: %d, count: %d\n", str, pid, cnt);write(wfd, buffer, strlen(buffer));cnt++;sleep(1);}
}
void reader(int rfd)
{char buffer[1024];while(1){ssize_t n = read(rfd, buffer, sizeof(buffer)-1);(void)n;printf("father get a message: %s", buffer);}
}int main()
{// 1. int pipefd[2];int n = pipe(pipefd);if(n < 0) return 1;printf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0]/*read*/, pipefd[1]/*write*/); // 3, 4// 2. pid_t id = fork();if(id == 0){//child: wclose(pipefd[0]);writer(pipefd[1]);exit(0);}// father: rclose(pipefd[1]);reader(pipefd[0]);wait(NULL);return 0;
}
2.3匿名管道的bug:
子进程继承父进程后,拷贝过父进程的文件描述表,后续子进程在创建的时候,会复制原先父进程的写端,就会导致管道有不止一个写端的BUG
比如这里的4就是子进程的4也是写端
我们的目的是让父进程和子进程之间只有一个写端一个读端,那如何修正这个问题呢?这就需要我们在子进程拷贝父进程的文件描述表的时候,将文件表的读写端口刷新!
3.匿名管道的读写规则
4种情况
- 管道内部没有数据&&子进程不关闭自己的写端文件fd,读端(富)就要阻塞等待,知道pipe有数据
- 管道内部被写满&&父进程(读端不关闭自己的fd,写端(子))写满之后,就要阻塞等待
- 对于写端而言:不写了&&关闭了pipe,读端会将pipe中的数据读完,最后就会读到返回值为0,表示读结束,类似读到了文件的结尾
- 读端不读&&关闭,写端在写,OS会直接终止写入的进程(子进程),通过信号13信号杀掉进程
5种特性:
- 自带同步机制
- 血缘关系进程进行通信,常见于父子
- pipe是面向字节流的
- 父子退出,管道自动释放,文件的声明中周期是随进程的
- 管道只能单向通信,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道
曾经我们学习的命令行管道(匿名),本质就是我们今天学习的pipe。
在父端写,子端读的情况下子进程的读端为什么都是3?
解释:刚开始父进程3是读端,4是写端,子进程会继承父进程的读写端口。下面是父端写,子端读的情况,那么就需要将父端的读关掉,就是将3关掉,然后将子进程的写端关掉,也就是将子进程的4关掉。父进程会循环创建管道,创建子进程。
所以父进程就会分配两个端口给这个管道进行读写,此时的3就被分配给了读端,5分配给了写端
子进程会拷贝父进程的文件描述表,所以3也是子进程的读端,5就是写端。这样父亲又开始写了,所以父进程的读端3就会被丢掉,子进程要写,那么就把5丢掉了。那么以此类推,所以子进程的读端一直都是3
4.命名管道
4.1.管道的本质
让不同的进程之间可以通信,让不同的进程看到同一份资源(文件)!
那么你怎么保证两个不同的进程打开的是同一个文件?如何让不同的进程看到同一份资源呢?
找到文件:文件的路径 + 文件名
匿名管道应用的一个限制就是只能在具有共同祖先(具有亲缘关系)的进程间通信。
如果我们想在不相关的进程之间交换数据,可以使用FIFO文件来做这项工作,它经常被称为命名管道。
注意命名管道是一种特殊类型的文件!
4.2创建一个命名管道
命名管道可以从命令行上创建,命令行方法是使用下面这个命令:
$ mkfifo filename
命名管道也可以从程序里创建,相关函数有
int mkfifo(const char *filename,mode_t mode);
头文件:
返回值
程序里面创建命名管道
int main(int argc, char *argv[])
{
mkfifo("p2", 0644);
return 0;
}
生成多个可执行程序的方法
4.3.匿名管道与命名管道的区别
- 匿名管道由pipe函数创建并打开。
- 命名管道由mkfifo函数创建,打开用open
- FIFO(命名管道)与pipe(匿名管道)之间唯一的区别在它们创建与打开的方式不同,一但这些工作完成之后,它们具有相同的语义。
- 命名管道和匿名管道之间的主要差异就是,命名管道可以让两个没有任何关系的进程进行通信
4.4用命名管道实现server&client通信
PipeClient.cc
#include "Comm.hpp"int main()
{int wfd = open(Path, O_WRONLY);if (wfd < 0){cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;return 1;}string inbuffer;while (true){cout << "Please Enter Your Message# ";std::getline(cin, inbuffer);if(inbuffer == "quit") break;ssize_t n = write(wfd, inbuffer.c_str(), inbuffer.size());if (n < 0){cerr << "write failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;break;}}close(wfd);return 0;
}
Comm.hpp
#ifndef __COMM_HPP__
#define __COMM_HPP__#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>using namespace std;#define Mode 0666
#define Path "./fifo"class Fifo
{
public:Fifo(const string &path) : _path(path){umask(0);int n = mkfifo(_path.c_str(), Mode);if (n == 0){cout << "mkfifo success" << endl;}else{cerr << "mkfifo failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;}}~Fifo(){int n = unlink(_path.c_str());if (n == 0){cout << "remove fifo file " << _path << " success" << endl;}else{cerr << "remove failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;}}private:string _path; // 文件路径+文件名
};#endif
PipeServer.cc
#include "Comm.hpp"
#include <unistd.h>// 基于命名管道,创建一个进程池呢???
int main()
{Fifo fifo(Path);int rfd = open(Path, O_RDONLY);if (rfd < 0){cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;return 1;}// 如果我们的写端没打开,先读打开,open的时候就会阻塞,直到把写端打开,读open才会返回cout << "open success" << endl;char buffer[1024];while (true){ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);if (n > 0){buffer[n] = 0;cout << "client say : " << buffer << endl;}else if (n == 0){cout << "client quit, me too!!" << endl;break;}else{cerr << "read failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;break;}}close(rfd);return 0;
}
5.共享内存方式通信:
上面我们讲述的是关于管道通信方式,下面我们来讲解共享内存的通信方式。
5.1共享内存如何实现让不同的进程看到同一份资源呢?
- 我们首先在内存中开辟一段空间,是由操作系统开辟的
- 接着让这份共享内存对不同的进程构建映射
- 移除映射
- 删除共享内存
共享内存在内核中同时可以存在很多个,OS必须要管理所有的共享内存。如何管理呢?先描述,再组织。系统中会存在很多共享内存!
那么我们怎么保证,两个或者多个不同的进程看到的是同一个共享内存呢?
所以我们要给共享内存提供唯一性的标识!
5.2.关于共享内存的函数
shmget函数
功能:用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);
参数
key:共享内存在内核中的唯一性标识
size:共享内存大小
shmflg:由九个权限标志构成,它们的用法和创建文件时使用的mode模式标志是一样的
返回值:成功返回一个非负整数,即该共享内存段的标识码;失败返回-1
shmflg标志讲解:
问题1:这个key是怎么形成的?意义是什么?
使用函数ftok来生成key,并且这个函数的参数可以随便传;key的值是多少并不重要,只要能够标识唯一性即可。
问题2:在调用shmget函数时,为什么要让用户传入key值呢?
因为当我们一个进程使用ftok函数有了唯一性的标识后,我们两个不同的进程只需要输入相同的key值就可以看见共享内存了!这个key值相当于一个桥梁,沟通了两个不同的进程去看见了同一份共享内存!!!让OS传,OS做不到!
shmctl函数删除共享内存
功能:用于控制共享内存
原型
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数
shmid:由shmget返回的共享内存标识码
cmd:将要采取的动作(有三个可取值)
buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值:成功返回0;失败返回-1
shmat函数挂接共享内存
功能:将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数
shmid: 共享内存标识
shmaddr:指定连接的地址,用户指明将shm挂接到哪里
shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值:成功返回一个指针,指向共享内存第一个节;失败返回-1
shmdt函数去关联
功能:将共享内存段与当前进程脱离
原型
int shmdt(const void *shmaddr);
参数
shmaddr: 由shmat所返回的指针
返回值:成功返回0;失败返回-1
注意:将共享内存段与当前进程脱离不等于删除共享内存段
5.3共享内存的大小
在内核中,共享内存的大小是以4kb为基本单位的,即便自己想要4kb—+1内存的空间,但是内核里创建的是8kb的内存,但只给你使用4kb+1的空间,所以其余字节被浪费掉了。建议共享内存申请大小是4kb的整数倍。
5.4共享内存的原理
使用共享内存通信,一定是一个进程创建新的共享内存,另一个直接获取共享内存即可。
共享内存,如果进程结束,我们没有主动释放它,则共享内存一直存在(除非重启系统)。这也就意味着共享内存的生命周期是随系统内核的!
5.5.key和shmid到底有什么区别
我们可以使用ipcs -m指令来查看系统中指定用户创建的共享内存。
发现共享内存有以下属性:
- key:在内核角度,区分共享内存的唯一性!
- shmid:在用户角度,无论是指令级还是代码级,最后对共享内存进行控制,用的都是shmid!
5.6.共享内存的优缺点
优点:共享内存是所有进程间通信中速度最快的
为什么共享内存是所有进程间通信中速度最快的?
因为假如有两个进程A、B,当进程A把数据放到共享内存当中时,进程B能够直接看到,因为共享内存使用的是用户空间。
而管道通信,进程A如果需要将数据传输到进程B时,必须经过系统调用,将数据拷贝到管道中,而进程B再从管道中拷贝数据到进程B,所以管道通信经历了很多次拷贝,通信速度自然就慢了!
所以此时的系统调用函数write、read函数本质其实就是拷贝资源!
缺点:
共享内存不提供进程间协同的任何机制,所以就会造成数据不一致的情况。
所以我们怎么解决这个问题呢?我们采用信号量或者用管道进行处理(管道本身是有同步属性的)
用管道来实现两个进程的信息的协同。
6、信号量
6.1.关于信号量的理论知识
- 临界资源:被保护起来的,任何时刻只允许一个线程执行访问的公共资源
- 临界区:访问临界资源的代码,临界区是代码,而临界资源是代码管理的资源
- 原子性:操作对象的时候,只有两种状态:要么还没开始,要么已经结束。
- 对于共享资源进行保护,是一个多执行流场景下,一个比较常见和重要的话题
- 互斥:在访问一部分共享资源的时候,任何时刻只有我一个人访问,就叫做互斥
- 同比:访问资源在安全的前提下,具有一定的顺序性
6.2.信号量的原理
为什么信号量也属于进程间通信的范畴呢?
我们首先要明白信号量本质是一个计数器,描述临界资源数量的计数器。
在多进程场景下,int全局变量是不能实现计数器的效果呢?
不能,有两个原因:
- 无法在进程间共享
- count++,count--不是原子的!
count需要先从内存中读取数据放在CPU上,然后CPU进行加法或者减法操作,最后再将数据放在内存当中。因此就不是原子性的。
为什么多进程还要考虑原子性的问题呢?因为如果不是原子性,加减不能立刻生效,就会对别的进程的数据产生影响。
在多进程场景下,int全局变量是不能实现计数器的效果的,因为无法在进程间共享!进程之间是独立的!
因此就需要我们的信号量充当计数器,如何充当呢?让不同的进程先看到同一份资源——计数器资源!!因此信号量本质也是跟进程间通信相关的!
所有的进程,访问临界资源,都必须先申请信号量——所有的进程都能看到同一个信号量——信号量本身就是共享资源(信号量++和--操作必须是原子的!)