【linux】进行间通信——共享内存+消息队列+信号量

这篇具有很好参考价值的文章主要介绍了【linux】进行间通信——共享内存+消息队列+信号量。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

进程间通信方式目前我们已经学了匿名管道,命名管道。让两个独立的进程通信,前提是看到同一份资源。匿名管道适用于血缘关系的进程,一个打开写端一个打开读端实现的。命名管道适用于完全独立的进程,打开同一份文件实现的。

接下来我们看看剩下的实现进程间通信的方式。

1.共享内存

1.1共享内存的原理

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
可执行程序加载到内存,OS会对进程进行管理。进程的内核结构是独立的,加载到物理地址的地址也独立,因此进程具有独立性,互不影响。

那共享内存是如何实现两个独立的进程进行通信的呢?

1.申请一块空间(用户给OS发信号,然后OS去申请)

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

2.将创建好的内存经过页表映射到进程地址空间中的一段区域(将这块区域的起始地址返回给用户,用户通过访问这里的起始地址方式来进行对这块区域的访问)

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

3.未来不想通信了
a.取消进程和内存的映射关系
b.释放内存

上面就是共享内存的原理。

这块申请的内存—>共享内存
进程和内存建立映射关系过程—>进程和共享内存挂接
取消进程和内存的映射关系—>去关联
释放内存—>释放共享内存

如何理解上面这个过程?

在内存上申请空间,然后把地址返回,是不是像C/C++空间的申请,如malloc函数,底层都是一样的先去物理内存申请空间,然后经过页表映射到进程地址空间,最后把这块空间的起始地址返回用户。虽然过程都是一样,但是malloc申请的空间没有办法让另一个进程看见,因为这块空间是在堆上申请的,OS并没有专门为malloc这样的机制和其他进程建立映射关系策略。

a.进程间通信,是专门设计的,用来IPC
b.共享内存是一种通信方式,所有想通信的进程,都可以用
c.OS中一定可能会同时存在很多的共享内存

1.2共享内存的概念

通过让不同的进程,看到同一个内存的方式:共享内存。

1.3接口的认识

1.创建共享内存。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
size 要申请多大的内存空间

shmflg 常用参数。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

看到这里这个参数是不是和open接口有点类似,大写的宏。

shmflg是一个标志位。

IPC_CREAT:如果想创建的共享内存不存在,就创建,如果存在就获取
IPC_EXCL:无法单独使用。
IPC_CREAT | IPC_EXCL:如果不存在就创建,如果存在就出错返回。用户创建共享内存如果成功,一定是一个新的共享内存。

创建共享内存非常容易,那如果保证进程看到的是同一块共享内存呢?
key用来保证。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
key是什么不重要,能进行唯一性标识最重要。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
将路径名和项目标识符转换为key。

随便写个路径和项目id。经过算法转换成key。
两个进程传一样参数,能保证是同一个key,因此可以在系统中找到同一个内存。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
返回值。成功是返回共享内存的标识符,失败返回-1。

再来理解key_t key

OS中一定可能会同时存在很多的共享内存。
OS也要对共享内存进行管理—>先描述,在组织。

申请一块空间—>共享内存=物理内存块+共享内存的相关属性

key是什么不重要,能进行唯一标识最重要。
创建共享内存的时候,key能保证共享内存在系统中的唯一性。两个进程如何看到同一份资源,只要另一个进程也看到同一个key。

key在那?
key在共享内存的相关属性这个结构体里。

创建共享内存把key传到shmget,本质上是把key设置进创建好的共享内存的某个属性里,另一个进程获取时,查这么多的共享内存,不是查共享内的物理内存块,而是去遍历共享内存对于的相关属性去查找key。

key传到shmget,设置到共享内存属性中,用来表示共享内存在内核中的唯一性。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

返回值返回的共享内存的标识符取名shmid。

shmid vs key的关系
shmid是为了用户去访问共享内存的。就像fd vs inode的关系。

2.共享内存和进程关联

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

shmid:和哪一个共享内存关联
shmaddr:把共享内存映射到地址空间的那一块区域
shmflg:与读写权限有关,默认设置为0

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
成功是返回的是对应进程地址空间的起始地址,失败返回-1。

3.删除共享内存之前要先去关联

将共享内存从当前调用这个函数的进程地址空间进行卸装

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
shmaddr:进程地址空间的首地址

4.删除共享内存

删除共享内存接口是shmctl,本质上控制共享内存,不过常用的是删除选项。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

shmid:控制哪一个共享内存
cmd:做什么控制,常用选项IPC_RMID
buf:如果不想获得共享内存的属性可以设置nullptr,不然就传一个对象接收共享内存部分属性信息。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

1.4实操

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

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);
}

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
看运行结果写端和读端的key是一样的,shmid也是一样的。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
当我再次执行一样的操作,发现不能再创建共享内存了。显示已经存在了。可是我已经退出进程了啊。OS不会帮我自动关闭吗。

共享内存的生命周期是随操作系统的,不是随进程的

查看IPC资源

ipcs查看IPC资源

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

ipcs -m 查看共享内存

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

ipcs -q 查看队列

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

ipcs -s 查信号量

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

ipcrm -m shmid 删除共享内存

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

代码删除共享内存

//删除共享内存
void DelShm(int shmid)
{
    if(shmctl(shmid,IPC_RMID,nullptr) == -1)
    {
        cerr<<errno<<":"<<strerror(errno)<<endl;
    }

}

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
通信之前需要关联(挂接:将共享内存经页表映射到进程地址空间)

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);
    }

看这个函数,我们可以直接把内容写到内存。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

完整代码如下

#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;
}

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
运行时报了这个没有权限的错误。【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
这是因为再创建共享内存的时候没有给权限。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
补上权限即可
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
看运行结果,虽然两个进程进行了通信,但是这个通信有点问题。
共享内存不像管道那样,阻塞等待,而是一直在读。

1.5共享内存的总结

共享内存的特点:

1.共享内存的生命周期是随OS的,不是随进程的。
2.所有进程间通信速度最快的(能大大的减少数据的拷贝次数)—>优点。

同样的代码,如果用管道来实现,综合考虑管道和共享内存,考虑键盘输入和显示器输出,共享内存有几次数据拷贝?管道呢?
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
3.不给我进行同步和互斥的操作,没有对数据做任何保护---->缺点

1.6共享内存的内核结构

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
给这个接口传一个struct shmid_de 对象,就看到共享内存一些信息。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

#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;
}

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
我们确实获得了共享内核的一些属性。

我们的key在struct shmid_ds结构体的第一个变量里。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

#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;
}

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

共享内存大小一般建议4KB(4096)的整数倍
系统分配共享内存是以4KB为单倍的!------内存划分内存块的基本单位page

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
虽然申请大小是4097,但是内核给你的实际是40962,内核给你向上取整。
虽然内核给的是4096
2,但是注意内核给你的,和你能用的是两码事。

2.消息队列

在前面说过System V IPC—>聚焦在本地通信,目前已经陈旧了,共享内存还是值得我们好好学习一番,剩下的我们看一看原理和接口就可以了。

2.1原理

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
进程A,B可以相互为读写段,一端把数据放到队列里,一端去拿。
那如何保证两个进程不会拿到自己的,而去拿对方的呢。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

这个队列内核数据结构中有一个type,用来标识,这个信息是谁发的,不是自己的不拿。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

2.2接口

创建一个消息队列

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

看到没这些参数和共享内存的参数非常相似。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

成功是返回消息队列标识符,失败返回-1。

向消息队列中放数据

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

msgp:发送的数据
msgsz:数据大小
msgflg:默认为0

接收数据

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
msgp:接收数据放到这里
msgsz:大小
msgtyp:类型

删除队列

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
这些接口都和共享内核相似。

3.信号量

关于信号量这里补充一些概念,也是为了后面的学习。

3.1信号量是什么

本质上是一个计数器,通常用来表示公共资源中,资源数量的多少问题。

信号量本质是一个计数器,那可以直接设置一个全局变量用来充当计数器吗?

不可以的,就如在匿名管道,设置一个全局变量,因为写时拷贝,父子进程看到的根本不是同一个全局变量。

进程通信之前要看到同一份资源,然后才能通信。
公共资源:被多个进程同时可以访问的资源。

以管道的方式通信的双方,注意到写端没写,读端一直在阻塞等待,读端没读,写端写完也在阻塞等待等等,而共享内存的方式呢,不管写端是否写完,读端一直在读。假设写一段数据,结果数据没写完就读。就造成了问题,这些数据就在共享内存中没有被保护。

访问没有被保护的公共资源导致数据不一致的问题。

我们来捋一捋这个过程。

为什么要让不同的进程看到同一份资源呢?
因为我想通信,让进程之间实现协同,但是进程具有独立性,因此需要先让进程看到同一份资源。 提出了方法,然后也引入了新的问题------>数据不一致问题。

我们未来将被保护起来的公共资源:临界资源
进程大部分的资源是独立的。

资源(内存,文件,网络)是要被使用的,如何被进程使用呢?
一定是该进程有对应的代码来访问这部分临界资源,这个代码临界区,其他代码叫非临界区。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

那如何保护公共资源呢?
互斥和同步
互斥:当有两个进程想访问一个公共资源的时候,我们只能让一个进程进行完整的访问。
同步,在多线程哪里再说。

还有一组概念比较不好理解。
假如我想向缓冲区写一段数据,要求我必须要把这段数据写完你才能读,我没写完你就读不了。对于我来讲,我在写的时候,我要么不写,要写就写完才对你有意义。
这种要么不做,要做就做完,两态的这种情况:原子性。

假设张三要去银行给李四转账200
张三1000 李四1000
1000-200 1000+200
但是网络出现问题,转账失败,那银行不能就不管了,必须要把这200还给张三保持原样。
转账对于我们来说就只有两态,要么不转,要转就转完,虽然可能有中间过程,但是最终结果就是要么不转,要转就转完。不会说正在转账中。
这就是我们所有的原子性。

上面说这么多主要是为了说明,让多进程和多线程用来进行原子性的互斥和同步,信号量是其中一种解决方案。

3.2为什么要信号量

举个例子

去电影票看电影,我是不是只要坐到座位上,这个位置才是属于我的?
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
并不是,买票(票号,座位号)之后,这个位置在那个时间段就是属于我的。

看电影买票的本质:对放映厅中座位进行进行预定机制。

当我们想要某种资源的时候,我们可以进行预定
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
电影院就相当于共享资源。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

每个进程想访问某些公共资源时,先申请信号量,申请成功就相当于预定了共享资源的某一部分资源,才能允许进入这个小资源里进行访问,申请失败,就不允许这个基础进入共享资源,进而达到保护共享资源以及其他基础的目的。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
所有进程在访问公共资源之前,都必须先申请sem信号量---->必须申请sem信号量的前提,是所有进程必须先看到同一个信号量---->信号量本身就是公共资源---->
信号量是不是也要保护自己的安全呢?(++,- - 操作)---->信号量必须要保护这种操作的安全性,++,- -操作是原子的!!!

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

++,- -就是我们所说的PV操作

信号量本质是一把计数器,这个计数器可以在多进程环境中,可以被多进程先看到,必须给我们匹配上两种操作,P操作,V操作,让进程对我们的共享资源进行访问。

如果信号量初始值是1,代表共享资源当作整体来使用,一个进程申请成功了,其他进程不能申请------->互斥。

提供互斥功能的信号量---->二元信号量。

这里可能有这样一个问题,进程申请成功了信号量,是有资格去访问共享资源,但具体是去访问那个资源子部分不知道,可能存在多个进程访问同一个资源的问题,(也就是买票(票号有了,座位号还没有))该怎么办?

这部分其实是由我们在写代码时来确认不同进程去访问那个资源的。

3.3接口

获取信号量

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
nsems:想申请几个信号量

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
申请成功返回一个信号量集的标识符。失败返回-1。

删除信号量,或者获取信号量属性

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
semnum:可能你申请很多信号量,这个是信号量对应的下标,申请一个信号量,下标为0,申请10个信号量,假设我想对第10个信号量操作,下标就是9。

cmd:删除,或者获取信号量相关属性。

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器

对信号量做PV操作

【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
对指定信号量,做对应的操作

struct sembuf结构有三个变量
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
sem_num:对申请的多个信号量,哪一个进行操作。
sem_op:一般只有两种值,一种是1代表++,V操作。一种是-1代表- -,P操作。
sem_flg:默认为0

nspos:有几个这样的结构体。

允许对多个信号量同时进行PV操作。

4.IPC资源的组织方式

我们注意到共享内存,消息队列,和信号量的接口都非常相似。都有struct …id_ds这样的结构体,还有对应描述IPC属性资源的第一个字段都是一样的。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
这三种共性可以看出来一个细节,这三种都叫做System V标准的进程间通信
所谓的标准就是,大家用的方式,接口设计,数据结构的设置都必须遵守某种标准。

那OS如何对管理这些(比如一会申请共享内存,一会消息队列,信号量)的呢?

OS并不是对它们本身进行管理,而是先描述在组织,对匹配的相关资源的内核结构进行管理。

因为当前三种方式的属性的第一个字段都是一样的。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
在内核中操作系统可以维护一个指针数组。
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
结构体第一个成员的地址,在数字上,和结构体对象本身的地址数字是相等的!!
【linux】进行间通信——共享内存+消息队列+信号量,Linux,linux,java,服务器
OS有对应的方式知道强转成什么结构体指针。

这就是OS对IPC资源的组织方式。文章来源地址https://www.toymoban.com/news/detail-752978.html

到了这里,关于【linux】进行间通信——共享内存+消息队列+信号量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux】System V 共享内存、消息队列、信号量

    🍎 作者: 阿润菜菜 📖 专栏: Linux系统编程 System V 共享内存是一种进程间通信的机制,它允许多个进程 共享一块物理内存区域 (称为“段”)。System V 共享内存的优点是效率高,因为进程之间不需要复制数据;缺点是 需要进程之间进行同步,以避免数据的不一致性 。 共

    2024年02月04日
    浏览(46)
  • Linux进程间通信【消息队列、信号量】

    ✨个人主页: 北 海 🎉所属专栏: Linux学习之旅 🎃操作环境: CentOS 7.6 阿里云远程服务器 在 System V 通信标准中,还有一种通信方式: 消息队列 ,以及一种实现互斥的工具: 信号量 ;随着时代的发展,这些陈旧的标准都已经较少使用了,但作为 IPC 中的经典知识,我们可

    2024年02月08日
    浏览(51)
  • 【C++】Windows下共享内存加信号量实现进程间同步通信

    目录 一,函数清单 1.CreateFileMapping 方法 2.OpenFileMapping 方法 3.MapViewOfFile 方法 4.UnmapViewOfFile 方法 5.CreateSemaphore 方法 6. OpenSemaphore 方法 7.WaitForSingleObject 方法 8.ReleaseSemaphore 方法 9.CloseHandle 方法 10.GetLastError 方法 二,单共享内存单信号量-进程间单向通信 共享内存管理文

    2024年02月08日
    浏览(40)
  • linux中互斥锁,自旋锁,条件变量,信号量,与freeRTOS中的消息队列,信号量,互斥量,事件的区别

    对于目前主流的RTOS的任务,大部分都属于并发的线程。 因为MCU上的资源每个任务都是共享的,可以认为是单进程多线程模型。 【freertos】003-任务基础知识 在没有操作系统的时候两个应用程序进行消息传递一般使用全局变量的方式,但是如果在使用操作系统的应用中用全局变

    2024年02月11日
    浏览(44)
  • 【STM32】FreeRTOS消息队列和信号量学习

    一、消息队列(queue) 队列是一种用于实现任务与任务之间,任务与中断之间消息交流的机制。 注意:1.数据的操作是FIFO模式。 2.队列需要明确数据的大小和队列的长度。 3.写和读都会出现堵塞。 实验:创建一个消息队列,两个发送任务,一个接收任务。 其中任务一任务三

    2024年02月13日
    浏览(39)
  • 学习系统编程No.22【消息队列和信号量】

    北京时间:2023/4/20/7:48,闹钟6点和6点30,全部错过,根本起不来,可能是因为感冒还没好,睡不够吧!并且今天是星期四,这个星期这是第二篇博客,作为一个日更选手,少些了两篇博客,充分摆烂,但是摆烂具体也是有原因的,星期一的时候莫名高烧,头昏脑涨的感觉,睡

    2023年04月27日
    浏览(40)
  • 【设计模式】C语言使用共享内存和信号量,完美实现生产者与消费者模式

    生产者和消费者模式适用于生产者和消费者之间存在数据交换的场景。在这种模式中,生产者负责生产数据并将其放入缓冲区,而消费者负责从缓冲区中取出数据并进行处理。这种模式的优点是可以实现生产者和消费者之间的解耦,使得它们可以独立地进行操作,从而提高了

    2024年02月03日
    浏览(36)
  • STM32 CubeMX (第二步Freertos任务通信:队列、信号量、互斥量,事件组,任务通知)

    学习使用Freertos第二步 在 FreeRTOS 中,任务通信可以通过以下函数来实现: xQueueCreate() :用于创建一个消息队列。可以设置队列长度和每个消息的大小。 xQueueSend() :将一条消息发送到队列中。可以选择阻塞或非阻塞发送。 xQueueReceive() :从队列中接收一条消息。可以选择阻塞

    2024年02月11日
    浏览(42)
  • Linux进程间通信 - 信号(signal) 与 管道(pipe) 与 消息队列

    什么是进程间通信,就是进程与进程之间进行通信,互相发送消息;可以通过 信号 或者 管道 或者 消息队列 或者 信号量 去通信! 目录 一、信号 1. 信号简介  2. 都有那些信号? 3. 注册信号的函数 1). signal 2). sigaction (项目中强烈推荐使用) 4. 信号发送 1). kill 函数 2). alarm 函

    2024年02月01日
    浏览(38)
  • 【Linux】进程间通信 -- 信号量

    信号量是什么? 本质是一个计数器,通常用来表示公共资源中,资源数量多少的问题 公共资源:能被多个进程同时可以访问的资源 访问没有保护的公共资源:数据不一致问题(比如我想写abc123,但是我123还没有写入,就读取了abc,可能数据分开会导致数据无意义) 为什么要

    2024年02月16日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包