共享内存+消息队列+信号量
进程间通信方式目前我们已经学了匿名管道，命名管道。让两个独立的进程通信，前提是看到同一份资源。匿名管道适用于血缘关系的进程，一个打开写端一个打开读端实现的。命名管道适用于完全独立的进程，打开同一份文件实现的。
接下来我们看看剩下的实现进程间通信的方式。
1.共享内存
1.1共享内存的原理
可执行程序加载到内存，OS会对进程进行管理。进程的内核结构是独立的，加载到物理地址的地址也独立，因此进程具有独立性，互不影响。
那共享内存是如何实现两个独立的进程进行通信的呢？
1.申请一块空间（用户给OS发信号，然后OS去申请）
2.将创建好的内存经过页表映射到进程地址空间中的一段区域（将这块区域的起始地址返回给用户，用户通过访问这里的起始地址方式来进行对这块区域的访问）
3.未来不想通信了
a.取消进程和内存的映射关系
b.释放内存
上面就是共享内存的原理。
这块申请的内存—>共享内存
进程和内存建立映射关系过程—>进程和共享内存挂接
取消进程和内存的映射关系—>去关联
释放内存—>释放共享内存
如何理解上面这个过程？
在内存上申请空间，然后把地址返回，是不是像C/C++空间的申请，如malloc函数，底层都是一样的先去物理内存申请空间，然后经过页表映射到进程地址空间，最后把这块空间的起始地址返回用户。虽然过程都是一样，但是malloc申请的空间没有办法让另一个进程看见，因为这块空间是在堆上申请的，OS并没有专门为malloc这样的机制和其他进程建立映射关系策略。
a.进程间通信，是专门设计的，用来IPC
b.共享内存是一种通信方式，所有想通信的进程，都可以用
c.OS中一定可能会同时存在很多的共享内存
1.2共享内存的概念
通过让不同的进程，看到同一个内存的方式：共享内存。
1.3接口的认识
1.创建共享内存。
size 要申请多大的内存空间
shmflg 常用参数。
看到这里这个参数是不是和open接口有点类似，大写的宏。
shmflg是一个标志位。
IPC_CREAT：如果想创建的共享内存不存在，就创建，如果存在就获取
IPC_EXCL：无法单独使用。
IPC_CREAT | IPC_EXCL：如果不存在就创建，如果存在就出错返回。用户创建共享内存如果成功，一定是一个新的共享内存。
创建共享内存非常容易，那如果保证进程看到的是同一块共享内存呢？
key用来保证。
key是什么不重要，能进行唯一性标识最重要。
将路径名和项目标识符转换为key。
随便写个路径和项目id。经过算法转换成key。
两个进程传一样参数，能保证是同一个key，因此可以在系统中找到同一个内存。
返回值。成功是返回共享内存的标识符，失败返回-1。
再来理解key_t key
OS中一定可能会同时存在很多的共享内存。
OS也要对共享内存进行管理—>先描述，在组织。
申请一块空间—>共享内存=物理内存块+共享内存的相关属性
key是什么不重要，能进行唯一标识最重要。
创建共享内存的时候，key能保证共享内存在系统中的唯一性。两个进程如何看到同一份资源，只要另一个进程也看到同一个key。
key在那？
key在共享内存的相关属性这个结构体里。
创建共享内存把key传到shmget，本质上是把key设置进创建好的共享内存的某个属性里，另一个进程获取时，查这么多的共享内存，不是查共享内的物理内存块，而是去遍历共享内存对于的相关属性去查找key。
key传到shmget，设置到共享内存属性中，用来表示共享内存在内核中的唯一性。
返回值返回的共享内存的标识符取名shmid。
shmid vs key的关系
shmid是为了用户去访问共享内存的。就像fd vs inode的关系。
2.共享内存和进程关联
shmid：和哪一个共享内存关联
shmaddr：把共享内存映射到地址空间的那一块区域
shmflg：与读写权限有关，默认设置为0
成功是返回的是对应进程地址空间的起始地址，失败返回-1。
3.删除共享内存之前要先去关联
将共享内存从当前调用这个函数的进程地址空间进行卸装
shmaddr：进程地址空间的首地址
4.删除共享内存
删除共享内存接口是shmctl，本质上控制共享内存，不过常用的是删除选项。
shmid：控制哪一个共享内存
cmd：做什么控制，常用选项IPC_RMID
buf：如果不想获得共享内存的属性可以设置nullptr，不然就传一个对象接收共享内存部分属性信息。
1.4实操
comm.hpp
将写端和读端用的代码封装起来。
#include<iostream>#include<cerrno>#include<cstring>#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#definePATHNAME"."#definePROJ_JD"0x11"#defineMAX_SIZE4096
key_t GetKey(){
key_t k=ftok(PATHNAME,PROJ_JD);//获得唯一标识keyif(k <0){//cin cout cerr->stdin stdout stderr(默认打开的三个文件)-(fd)>0,1,2->键盘，显示器，显示器
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}return k;}//获得共享内存表示符shmidintgetShmHelper(int key,int shmflg){int shmid=shemget(key,MAX_SIZE,shmflg);if(shmid <0){
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}return shmid;}//写端创建共享内存intCreateShm(key_t key){//这里运行时会报错。下面再看运行结果有解决方法returngetShmHelper(key,IPC_CREAT|IPC_EXCL);}//读端获取共享内存intGetShm(){returngetShmHelper(key,IPC_CREAT);}
看运行结果写端和读端的key是一样的，shmid也是一样的。
当我再次执行一样的操作，发现不能再创建共享内存了。显示已经存在了。可是我已经退出进程了啊。OS不会帮我自动关闭吗。
共享内存的生命周期是随操作系统的，不是随进程的
查看IPC资源
ipcs查看IPC资源
ipcs -m 查看共享内存
ipcs -q 查看队列
ipcs -s 查信号量
ipcrm -m shmid 删除共享内存
代码删除共享内存
//删除共享内存voidDelShm(int shmid){if(shmctl(shmid,IPC_RMID,nullptr)==-1){
cerr<<errno<<":"<<strerror(errno)<<endl;}}
通信之前需要关联（挂接：将共享内存经页表映射到进程地址空间）
void*attachShm(int shimid){void* mem=shmat(shimid,nullptr,0);//linux 64位机器指针大小位9if((longlong)men ==-1L)//1L代表是长整型{
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}return men;}
删除共享内存之前需要去关联
voiddetachShm(constvoid* adder){if(shmdt(adder)==-1){
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}}
完整代码如下
#include<iostream>#include<cerrno>#include<cstring>#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include<unistd.h>usingnamespace std;#definePATHNAME"."#definePROJ_JD0x11#defineMAX_SIZE4096
key_t GetKey(){
key_t k=ftok(PATHNAME,PROJ_JD);if(k <0){//cin cout cerr->stdin stdout stderr(默认打开的三个文件)-(fd)>0,1,2->键盘，显示器，显示器
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}return k;}//获得共享内存表示符shmidintgetShmHelper(int key,int flage){int shmid=shmget(key,MAX_SIZE,flage);if(shmid <0){
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}return shmid;}//写端创建共享内存intCreateShm(key_t key){//这里运行时会报错。下面再看运行结果有解决方法returngetShmHelper(key,IPC_CREAT|IPC_EXCL);}//读端获取共享内存intGetShm(key_t key){returngetShmHelper(key,IPC_CREAT);}//关联void*attachShm(int shimid){void* mem=shmat(shimid,nullptr,0);//linux 64位机器指针大小位9if((longlong)mem ==-1L)//1L代表是长整型{
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}return mem;}//去关联voiddetachShm(constvoid* adder){if(shmdt(adder)==-1){
cerr<<errno<<":"<<strerror(errno)<<endl;exit(1);}}//删除共享内存voidDelShm(int shmid){if(shmctl(shmid,IPC_RMID,nullptr)==-1){
cerr<<errno<<":"<<strerror(errno)<<endl;}}
service.cc （写）
#include"comm.hpp"intmain(){
key_t key=GetKey();printf("key->%d\n",key);int shmid=CreateShm(key);printf("shimid->%d\n",shmid);//关联char*start=(char*)attachShm(shmid);//我想将这个地址认为是一字符串;printf("attach success, address start: %p\n", start);//写while(true){}//删除DelShm(shmid);return0;}
共享内存没有read和write这样的接口。
写—>直接把内容写到这块内存
读—>直接打印这块内存
以往我们可能是这样的写法，对于往内存中写有点麻烦了。
//写char buffer[1024];constchar* messge="hello clint,我是另一个进程,我正在和你通信";int id=getpid();int cnt=0;while(true){//以往我们的做法snprintf(buffer,sizeof buffer,"%s([%d]->[%d])",messge,cnt++,id);memcpy(start,buffer,strlen(buffer)+1);}
看这个函数，我们可以直接把内容写到内存。
完整代码如下
#include"comm.hpp"intmain(){
key_t key=GetKey();printf("key->%d\n",key);int shmid=CreateShm(key);printf("shimid->%d\n",shmid);//关联char* start=(char*)attachShm(shmid);//我想将这个地址认为是一字符串;printf("attach success, address start: %p\n", start);//写char buffer[1024];constchar* messge="hello clint,我是另一个进程,我正在和你通信";int id=getpid();int cnt=0;while(true){snprintf(start,MAX_SIZE,"%s([%d]->[%d])",messge,cnt++,id);//以往我们的做法// snprintf(buffer,sizeof buffer,"%s([%d]->[%d])",messge,cnt++,id));// memcpy(start,buffer,strlen(buffer)+1);}//去关联detachShm(start);//删除DelShm(shmid);return0;}
clint.cc （读）
#include"comm.hpp"intmain(){
key_t key=GetKey();printf("key->%d\n",key);int shmid=GetShm(key);printf("shimid->%d\n",shmid);char* start=(char*)attachShm(shmid);printf("attach success, address start: %p\n", start);while(true){printf("service say : %s\n", start);}return0;}
运行时报了这个没有权限的错误。
这是因为再创建共享内存的时候没有给权限。
补上权限即可
看运行结果，虽然两个进程进行了通信，但是这个通信有点问题。
共享内存不像管道那样，阻塞等待，而是一直在读。
1.5共享内存的总结
共享内存的特点：
1.共享内存的生命周期是随OS的，不是随进程的。
2.所有进程间通信速度最快的（能大大的减少数据的拷贝次数）—>优点。
同样的代码，如果用管道来实现，综合考虑管道和共享内存，考虑键盘输入和显示器输出，共享内存有几次数据拷贝？管道呢？
3.不给我进行同步和互斥的操作，没有对数据做任何保护---->缺点
1.6共享内存的内核结构
给这个接口传一个struct shmid_de 对象，就看到共享内存一些信息。
#include"comm.hpp"intmain(){
key_t key=GetKey();printf("key->%d\n",key);int shmid=GetShm(key);printf("shimid->%d\n",shmid);char* start=(char*)attachShm(shmid);printf("attach success, address start: %p\n", start);while(true){printf("service say : %s\n", start);structshmid_ds ds;shmctl(shmid,IPC_STAT,&ds);printf("获得属性: size :%d,link :%d\n",ds.shm_segsz,ds.shm_nattch);sleep(1);}return0;}
我们确实获得了共享内核的一些属性。
我们的key在struct shmid_ds结构体的第一个变量里。
#include"comm.hpp"intmain(){
key_t key=GetKey();printf("key->%d\n",key);int shmid=GetShm(key);printf("shimid->%d\n",shmid);char* start=(char*)attachShm(shmid);printf("attach success, address start: %p\n", start);while(true){printf("service say : %s\n", start);structshmid_ds ds;shmctl(shmid,IPC_STAT,&ds);printf("获得属性: size :%d,link :%d,key :%d\n",\
ds.shm_segsz,ds.shm_nattch,ds.shm_perm.__key);sleep(1);}return0;}
共享内存大小一般建议4KB（4096）的整数倍
系统分配共享内存是以4KB为单倍的！------内存划分内存块的基本单位page
虽然申请大小是4097，但是内核给你的实际是40962，内核给你向上取整。
虽然内核给的是40962，但是注意内核给你的，和你能用的是两码事。
2.消息队列
在前面说过System V IPC—>聚焦在本地通信，目前已经陈旧了，共享内存还是值得我们好好学习一番，剩下的我们看一看原理和接口就可以了。
2.1原理
进程A，B可以相互为读写段，一端把数据放到队列里，一端去拿。
那如何保证两个进程不会拿到自己的，而去拿对方的呢。
这个队列内核数据结构中有一个type，用来标识，这个信息是谁发的，不是自己的不拿。
2.2接口
创建一个消息队列
看到没这些参数和共享内存的参数非常相似。
成功是返回消息队列标识符，失败返回-1。
向消息队列中放数据
msgp:发送的数据
msgsz：数据大小
msgflg：默认为0
接收数据
msgp：接收数据放到这里
msgsz：大小
msgtyp：类型
删除队列
这些接口都和共享内核相似。
3.信号量
关于信号量这里补充一些概念，也是为了后面的学习。
3.1信号量是什么
本质上是一个计数器，通常用来表示公共资源中，资源数量的多少问题。
信号量本质是一个计数器，那可以直接设置一个全局变量用来充当计数器吗？
不可以的，就如在匿名管道，设置一个全局变量，因为写时拷贝，父子进程看到的根本不是同一个全局变量。
进程通信之前要看到同一份资源，然后才能通信。
公共资源：被多个进程同时可以访问的资源。
以管道的方式通信的双方，注意到写端没写，读端一直在阻塞等待，读端没读，写端写完也在阻塞等待等等，而共享内存的方式呢，不管写端是否写完，读端一直在读。假设写一段数据，结果数据没写完就读。就造成了问题，这些数据就在共享内存中没有被保护。
访问没有被保护的公共资源导致数据不一致的问题。
我们来捋一捋这个过程。
为什么要让不同的进程看到同一份资源呢？
因为我想通信，让进程之间实现协同，但是进程具有独立性，因此需要先让进程看到同一份资源。 提出了方法，然后也引入了新的问题------>数据不一致问题。
我们未来将被保护起来的公共资源：临界资源
进程大部分的资源是独立的。
资源(内存，文件，网络)是要被使用的，如何被进程使用呢？
一定是该进程有对应的代码来访问这部分临界资源，这个代码临界区，其他代码叫非临界区。
那如何保护公共资源呢？
互斥和同步
互斥：当有两个进程想访问一个公共资源的时候，我们只能让一个进程进行完整的访问。
同步，在多线程哪里再说。
还有一组概念比较不好理解。
假如我想向缓冲区写一段数据，要求我必须要把这段数据写完你才能读，我没写完你就读不了。对于我来讲，我在写的时候，我要么不写，要写就写完才对你有意义。
这种要么不做，要做就做完，两态的这种情况：原子性。
假设张三要去银行给李四转账200
张三1000 李四1000
1000-200 1000+200
但是网络出现问题，转账失败，那银行不能就不管了，必须要把这200还给张三保持原样。
转账对于我们来说就只有两态，要么不转，要转就转完，虽然可能有中间过程，但是最终结果就是要么不转，要转就转完。不会说正在转账中。
这就是我们所有的原子性。
上面说这么多主要是为了说明，让多进程和多线程用来进行原子性的互斥和同步，信号量是其中一种解决方案。
3.2为什么要信号量
举个例子
去电影票看电影，我是不是只要坐到座位上，这个位置才是属于我的？
并不是，买票（票号，座位号）之后，这个位置在那个时间段就是属于我的。
看电影买票的本质：对放映厅中座位进行进行预定机制。
当我们想要某种资源的时候，我们可以进行预定。
电影院就相当于共享资源。
每个进程想访问某些公共资源时，先申请信号量，申请成功就相当于预定了共享资源的某一部分资源，才能允许进入这个小资源里进行访问，申请失败，就不允许这个基础进入共享资源，进而达到保护共享资源以及其他基础的目的。
所有进程在访问公共资源之前，都必须先申请sem信号量---->必须申请sem信号量的前提，是所有进程必须先看到同一个信号量---->信号量本身就是公共资源---->
信号量是不是也要保护自己的安全呢？(++，- - 操作)---->信号量必须要保护这种操作的安全性，++，- -操作是原子的！！！
++，- -就是我们所说的PV操作
信号量本质是一把计数器，这个计数器可以在多进程环境中，可以被多进程先看到，必须给我们匹配上两种操作，P操作，V操作，让进程对我们的共享资源进行访问。
如果信号量初始值是1，代表共享资源当作整体来使用，一个进程申请成功了，其他进程不能申请------->互斥。
提供互斥功能的信号量---->二元信号量。
这里可能有这样一个问题，进程申请成功了信号量，是有资格去访问共享资源，但具体是去访问那个资源子部分不知道，可能存在多个进程访问同一个资源的问题，（也就是买票（票号有了，座位号还没有））该怎么办？
这部分其实是由我们在写代码时来确认不同进程去访问那个资源的。
3.3接口
获取信号量
nsems:想申请几个信号量
申请成功返回一个信号量集的标识符。失败返回-1。
删除信号量，或者获取信号量属性
semnum：可能你申请很多信号量，这个是信号量对应的下标，申请一个信号量，下标为0，申请10个信号量，假设我想对第10个信号量操作，下标就是9。
cmd：删除，或者获取信号量相关属性。
对信号量做PV操作
对指定信号量，做对应的操作
struct sembuf结构有三个变量
sem_num：对申请的多个信号量，哪一个进行操作。
sem_op：一般只有两种值，一种是1代表++，V操作。一种是-1代表- -，P操作。
sem_flg：默认为0
nspos:有几个这样的结构体。
允许对多个信号量同时进行PV操作。
4.IPC资源的组织方式
我们注意到共享内存，消息队列，和信号量的接口都非常相似。都有struct …id_ds这样的结构体，还有对应描述IPC属性资源的第一个字段都是一样的。
这三种共性可以看出来一个细节，这三种都叫做System V标准的进程间通信。
所谓的标准就是，大家用的方式，接口设计，数据结构的设置都必须遵守某种标准。
那OS如何对管理这些（比如一会申请共享内存，一会消息队列，信号量）的呢？
OS并不是对它们本身进行管理，而是先描述在组织，对匹配的相关资源的内核结构进行管理。
因为当前三种方式的属性的第一个字段都是一样的。
在内核中操作系统可以维护一个指针数组。
结构体第一个成员的地址，在数字上，和结构体对象本身的地址数字是相等的！！
OS有对应的方式知道强转成什么结构体指针。
这就是OS对IPC资源的组织方式。
版权归原作者 LuckyRich1 所有， 如有侵权，请联系我们删除。