进程间通信方式目前我们已经学了匿名管道,命名管道。让两个独立的进程通信,前提是看到同一份资源。匿名管道适用于血缘关系的进程,一个打开写端一个打开读端实现的。命名管道适用于完全独立的进程,打开同一份文件实现的。
接下来我们看看剩下的实现进程间通信的方式。
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>
#define PATHNAME "."
#define PROJ_JD "0x11"
#define MAX_SIZE 4096
key_t GetKey()
{
key_t k=ftok(PATHNAME,PROJ_JD);//获得唯一标识key
if(k < 0)
{
//cin cout cerr->stdin stdout stderr(默认打开的三个文件)-(fd)>0,1,2->键盘,显示器,显示器
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return k;
}
//获得共享内存表示符shmid
int getShmHelper(int key,int shmflg)
{
int shmid=shemget(key,MAX_SIZE,shmflg);
if(shmid < 0)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return shmid;
}
//写端创建共享内存
int CreateShm(key_t key)
{
//这里运行时会报错。下面再看运行结果有解决方法
return getShmHelper(key,IPC_CREAT|IPC_EXCL);
}
//读端获取共享内存
int GetShm()
{
return getShmHelper(key,IPC_CREAT);
}
看运行结果写端和读端的key是一样的,shmid也是一样的。
当我再次执行一样的操作,发现不能再创建共享内存了。显示已经存在了。可是我已经退出进程了啊。OS不会帮我自动关闭吗。
共享内存的生命周期是随操作系统的,不是随进程的
查看IPC资源
ipcs查看IPC资源
ipcs -m 查看共享内存
ipcs -q 查看队列
ipcs -s 查信号量
ipcrm -m shmid 删除共享内存
代码删除共享内存
//删除共享内存
void DelShm(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位机器指针大小位9
if((long long)men == -1L)//1L代表是长整型
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return men;
}
删除共享内存之前需要去关联
void detachShm(const void* 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>
using namespace std;
#define PATHNAME "."
#define PROJ_JD 0x11
#define MAX_SIZE 4096
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;
}
//获得共享内存表示符shmid
int getShmHelper(int key,int flage)
{
int shmid=shmget(key,MAX_SIZE,flage);
if(shmid < 0)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return shmid;
}
//写端创建共享内存
int CreateShm(key_t key)
{
//这里运行时会报错。下面再看运行结果有解决方法
return getShmHelper(key,IPC_CREAT|IPC_EXCL);
}
//读端获取共享内存
int GetShm(key_t key)
{
return getShmHelper(key,IPC_CREAT);
}
//关联
void* attachShm(int shimid)
{
void* mem=shmat(shimid,nullptr,0);//linux 64位机器指针大小位9
if((long long)mem == -1L)//1L代表是长整型
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return mem;
}
//去关联
void detachShm(const void* adder)
{
if(shmdt(adder) == -1)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
}
//删除共享内存
void DelShm(int shmid)
{
if(shmctl(shmid,IPC_RMID,nullptr) == -1)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
}
}
service.cc (写)
#include"comm.hpp"
int main()
{
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);
return 0;
}
共享内存没有read和write这样的接口。
写—>直接把内容写到这块内存
读—>直接打印这块内存
以往我们可能是这样的写法,对于往内存中写有点麻烦了。
//写
char buffer[1024];
const char* 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"
int main()
{
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];
const char* 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);
return 0;
}
clint.cc (读)
#include"comm.hpp"
int main()
{
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);
}
return 0;
}
运行时报了这个没有权限的错误。
这是因为再创建共享内存的时候没有给权限。
补上权限即可
看运行结果,虽然两个进程进行了通信,但是这个通信有点问题。
共享内存不像管道那样,阻塞等待,而是一直在读。
1.5共享内存的总结
共享内存的特点:
1.共享内存的生命周期是随OS的,不是随进程的。
2.所有进程间通信速度最快的(能大大的减少数据的拷贝次数)—>优点。
同样的代码,如果用管道来实现,综合考虑管道和共享内存,考虑键盘输入和显示器输出,共享内存有几次数据拷贝?管道呢?
3.不给我进行同步和互斥的操作,没有对数据做任何保护---->缺点
1.6共享内存的内核结构
给这个接口传一个struct shmid_de 对象,就看到共享内存一些信息。
#include"comm.hpp"
int main()
{
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);
struct shmid_ds ds;
shmctl(shmid,IPC_STAT,&ds);
printf("获得属性: size :%d,link :%d\n",ds.shm_segsz,ds.shm_nattch);
sleep(1);
}
return 0;
}
我们确实获得了共享内核的一些属性。
我们的key在struct shmid_ds结构体的第一个变量里。
#include"comm.hpp"
int main()
{
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);
struct shmid_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);
}
return 0;
}
共享内存大小一般建议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有对应的方式知道强转成什么结构体指针。文章来源:https://www.toymoban.com/news/detail-752978.html
这就是OS对IPC资源的组织方式。文章来源地址https://www.toymoban.com/news/detail-752978.html
到了这里,关于【linux】进行间通信——共享内存+消息队列+信号量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!