【Linux】共享内存（超详细！）

已于 2023-08-16 15:53:13 修改
阅读量4.8k 收藏 31
点赞数 18
分类专栏： Linux系统编程 文章标签： 算法
于 2023-08-14 12:03:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzxz8/article/details/132268382
版权

一、共享内存原理：

通过在物理内存申请一段共享内存空间，这个空间可以被任何进程看见。然后将内存空间映射到想要以此进行通信的进程的进程地址空间中的共享区（堆栈之间），用户就可以直接使用这个虚拟起始地址进行数据传输和接收了。

二、共享内存内核数据结构：

当创建完共享内存后，OS为了管理这些共享内存，会创建内核数据结构来管理这些共享内存，每个结构体里面存放的是共享内存段的属性信息，类似于文件系统中的inode。

共享内存=共享内存内核数据结构（伪代码：struct shm）+真正开辟的内存空间

三、函数方法

1.shmget

//头文件
#include <sys/ipc.h>
#include <sys/shm.h>
   
//方法
static int shmHelper(key_t key,int size,int flag)
//static修饰的全局变量或函数，作用域被限定在当前文件内；
{

   int shmid=shmget(key,size,flag);
   if(shmid==-1)
    {
        cout<<"errno :"<<errno<<"|  error : "<<strerror(errno)<<endl;
        exit(2);
    }
    return shmid;

}

//创建共享内存
int createSharememory(key_t key,int size)
{
    return shmHelper(key,size,IPC_CREAT|IPC_EXCL|0666);//注意在创建的时候把读写权限0666带上，否则后面如果要读取shmid_ds数据结构的属性就读不到了。

}

//获取共享内存
int getSharememory(key_t key,int size)
{
    return shmHelper(key,size,IPC_CREAT);
  
}

描述：

翻译：

shmget（） 返回与参数键的key值关联的系统 V 共享内存段的标识符。 一个新的共享内存段，大小等于PAGE_SIZE的整数倍。

如果 shmflg 同时指定了 IPC_CREAT 和 IPC_EXCL，并且密钥的共享内存段已经存在，则 shmget（） 失败，errno 设置为 EEXIST。 如果shmflg只指定了IPC_CREAT，如果已经存在这段共享内存，那么就返回已存在的标识符，否则就创建一个共享内存段。

参数解析：

<1>

key_t key就是一个整型数据，相当于一个钥匙，它是进程创建共享内存的钥匙，也是其它想与之通信的进程的钥匙。A进程设置好key具体是什么，并且使用shmget（key,size,IPC_CREAT | IPC_EXCL）创建完成共享内存之后，B进程就可以使用shmget（key,size,IPC_CREAT）获取共享内存标识符。

key其实是可以随意设置的，但是我们一般使用ftok函数。使用路径名加上项目id可以创建出一个冲突概率非常低的key值。

#include <sys/types.h>
#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);



#define PATHNAME "."//当前路径
#define PROJID 0x666//随意proj_id

//封装好的getKey函数
key_t getKey()
{
    key_t key=ftok(PATHNAME,PROJID); 
    if(key==-1)
    {
//On success, the generated key_t value is returned.  On failure -1 is returned, with errno indicating the error as for the stat(2) system call.
        cout<<"errno :"<<errno<<"|  error : "<<strerror(errno)<<endl;
        exit(1);
    }
    return key;
}

共享内存的内核数据结构里面包含有key，所以其他进程才能通过key找到相应的共享内存，并得到共享内存的shmid；

<2>

size_t size就是想要申请的共享内存块的大小，单位是字节。但实际上操作系统会根据用户想要申请的字节数判断这段共享内存给多大。因为对于操作系统来说单位是PAGE_SIZE,也就是4KB，4096字节，一个数据块的大小。所以共享内存大小就是PAGE_SIZE的整数倍。但是如果你使用共享内存的时候，超过你所申请的字节数，操作系统会报错。

<3>

shmflg就是权限标志。如果 shmflg 同时指定了 IPC_CREAT 和 IPC_EXCL，并且密钥的共享内存段已经存在，则 shmget（） 失败，errno 设置为 EEXIST。 如果shmflg只指定了IPC_CREAT，如果已经存在这段共享内存，那么就返回已存在的标识符，否则就创建一个共享内存段。

返回值：

如果成功返回一个共享内存标识符，失败就返回-1；

2.shmat

#include <sys/types.h>
#include <sys/shm.h>

void *shmat(int shmid, const void *shmaddr, int shmflg);

该函数意为把申请好的共享内存和进程挂接起来，就是把共享内存的物理地址通过页表映射到进程地址空间中的共享区，可以让进程直接访问到共享内存，最后返回虚拟地址。这里类似于malloc函数，只不过malloc函数是在真实使用的时候才分配物理内存，申请的时候只是给了虚拟地址罢了，等到使用的时候通过页表将物理内存和虚拟地址映射起来。而共享内存的挂接是之前就已经有真实的物理内存了。

参数解析：

const void* shamaddr是让我们设置虚拟地址，这里我们交给操作系统就好，设为nullptr即可。

shmflg设为0就行，就是读写权限。

返回值：

RETURN VALUE
       On success shmat() returns the address of the attached shared memory segment; on error (void *) -1 is returned, and errno is set to indicate the cause of the error.

dest情况解释：

当创建共享内存的A进程把共享内存删除了，而之前关联共享内存的B进程还在的话，status就会呈现下图中dest这样的情况。我们要尽量避免这样的情况（虽然等所有关联该共享内存的进程自动退出也可以），在共享内存被删除之前，我们就要取消所有进程的关联--->shmdt函数。

所以，共享内存只有在当前映射连接数为0时才会被删除释放。

代码:

//把返回的虚拟地址由void*强转成char*，方便我们后续使用，来IOcahr类型的数据； 
char* start=(char*)shmat(shmid,nullptr,0);

3.shmdt（取消关联）

#include <sys/types.h>
#include <sys/shm.h>

int shmdt(const void *shmaddr);

参数解析：

shmaddr是共享内存映射在进程地址空间的虚拟地址，只需要用这个虚拟地址，就可以取消页表对共享内存空间的映射，从而达到该进程取消关联共享内存的目的。

返回值：

 On success shmdt() returns 0; on error -1 is returned, and errno is set to indicate the cause of the error.

4.shmctl

<1>命令:

ipcrm -m shmid

<2>系统调用

#include <sys/ipc.h>
#include <sys/shm.h>

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

参数解析：

<1>

shmid就是所创建的共享内存标识符。

<2>

 cmd:图中红色标记意为如果要使用IPC_STAT，拷贝属性信息到自己定义的输出型参数strcut shmid_ds结构体中，必须要有对共享内存的读权限。那么只要在创建的时候设置读权限就好了

经过如下代码：

  struct shmid_ds ds;//在这里相当于一个输出型参数
    int n=shmctl(shmid,IPC_STAT,&ds);
    if(n!=-1)
    {
        cout<<"创建进程的pid : "<<ds.shm_cpid<<endl;
        cout<<"共享内存的大小 : "<<ds.shm_segsz<<endl;
        cout<<"本进程的pid : "<<getpid()<<endl;

    }

  static int shmHelper(key_t key,int size,int flag)
{

   int shmid=shmget(key,size,flag);
   if(shmid==-1)
    {
        cout<<"errno :"<<errno<<"|  error : "<<strerror(errno)<<endl;
        exit(2);
    }
    return shmid;
}

//创建共享内存
int createSharememory(key_t key,int size)
{
    umask(0);
    //创建共享内存时设置666权限；
    return shmHelper(key,size,IPC_CREAT|IPC_EXCL|0666);

}

 结果就变成下图所示了：

下图就是man手册中的cmd选项：

<3>

struct shmid_ds*buf是指向内核数据结构的指针，这个内核数据结构里面存放的是一些共享内存的属性，比如大小，创建进程的pid等等。

（IPC_RMID）删除结果：

//删除共享内存
void  delshm(int shmid)
{
    int n=shmctl(shmid,IPC_RMID,nullptr);
    assert(n!=-1);
    (void)n;
}

那么这里有一个问题，只有起始地址，操作系统怎么知道删除多大空间呢？

解释：因为物理内存里面还有关于共享内存的内核数据结构，里面存有共享内存所有的属性，相当于额外申请出来的空间，既然有了属性，那么不就知道该删除多大了吗。

这就对应了前面所说的共享内存=共享内存内核数据结构+真正开辟的内存空间。

进程退出共享内存并不会被销毁。管道随进程生命周期的结束而结束，但是共享内存却不会，需要我们手动销毁。

 再次使用同样的key创建共享内存会出错：因为该共享内存已经存在

我们使用shmid删除以后：

四、训练代码：

comm.hpp:


#ifndef _COMM_HPP_
#define _COMM_HPP_

#include<iostream>
#include<cerrno>
#include<cstring>
#include<cassert>


#include<string>
#include<sys/shm.h>
#include<sys/ipc.h>
#include<sys/types.h>
#include<cstdio>
#include<unistd.h>
#include<sys/stat.h>




using namespace std;



#define PATHNAME "."//当前路径
#define PROJID 0x666//随便，不影响
#define M_SIZE 4096//共享内存大小

//枚举
typedef enum Type
{
   Client,
   Server
}Type;




class shmInit
{
public:
    //构造函数
    shmInit(Type type)
    :_type(type)
    {
        //获取key
        int key=getKey();

        if(_type==Server)
        {
           _shmid=createSharememory(key,M_SIZE);
        }
        else
        {
           _shmid=getSharememory(key,M_SIZE);
            
        }
        //关联
        _start=attachshm(_shmid);
    
    }

    //析构函数
    ~shmInit()
    {
        //取消关联
        detachshm(_start);
          
         if(_type==Server)
        {
            //删除共享内存
           delshm(_shmid);
        }

    }

    

    char* get_start()
    {
        return _start;
    }
    
    int get_shmid()
    {
        return _shmid;
    }



private:
    //static修饰的全能变量或函数，作用域被限定在当前文件内；
    static int shmHelper(key_t key,int size,int flag)
    {

    int shmid=shmget(key,size,flag);
    if(shmid==-1)
        {
            cout<<"errno :"<<errno<<"|  error : "<<strerror(errno)<<endl;
            exit(2);
        }
        return shmid;
    }
    //得到key
    key_t getKey()
    {
        key_t key=ftok(PATHNAME,PROJID); 
        if(key==-1)
        {
    //On success, the generated key_t value is returned.  On failure -1 is returned, with errno indicating the error as for the stat(2) system call.
            cout<<"errno :"<<errno<<"|  error : "<<strerror(errno)<<endl;
            exit(1);
        }
        return key;
    }

    //创建共享内存
    int createSharememory(key_t key,int size)
    {
        return shmHelper(key,size,IPC_CREAT|IPC_EXCL|0666);

    }

    //获取共享内存
    int getSharememory(key_t key,int size)
    {
        return shmHelper(key,size,IPC_CREAT);
    
    }

    //关联
    char* attachshm(int shmid)
    {
        char* start=(char*)shmat(shmid,nullptr,0);//把返回的虚拟地址由void*强转成char*，方便我们后续使用，来IOcahr类型的数据；
        
        return start;
    }

    //去关联
    void detachshm(char* start)
    {
        int n=shmdt(start);//只需要共享内存起始虚拟地址作为参数；
        assert(n!=-1);
        (void)n;
    } 
    //删除共享内存
    void  delshm(int shmid)
    {
        int n=shmctl(shmid,IPC_RMID,nullptr);
        assert(n!=-1);
        (void)n;
    }       

private:
    char* _start;
    Type _type;
    int _shmid;

};


#endif

shmclient.cc

#include "comm.hpp"

int main()
{
    Type type=Client;
    shmInit shm(type);

    char *start=shm.get_start();

    //通信
    int n=0;

    while(n<26)
    {
        
        start[n]='A'+n;
        sleep(1);
        n++;
        start[n]='\0';
    }


  

    return 0;
}

shmserver.cc

#include "comm.hpp"


int main()
{
    Type type=Server;
    shmInit shm(type);

   
    char *start=shm.get_start();

    //通信
    int n=26;
    while(n>=0)
    {
        //标准输出
        cout<<"Client->Server# "<<start<<endl;
        sleep(1);
        n--;
    }

  



 

 
   // struct shmid_ds ds;//在这里相当于一个输出型参数
    // int n=shmctl(shmid,IPC_STAT,&ds);
    // if(n!=-1)
    // {
    //     cout<<"创建进程的pid : "<<ds.shm_cpid<<endl;
    //     cout<<"共享内存的大小 : "<<ds.shm_segsz<<endl;
    //     cout<<"本进程的pid : "<<getpid()<<endl;

    // }
  

    return 0;
}

makefile

.PHONY:all
all:shmclient shmserver
shmclient:shmclient.cc
	g++ $^ -o $@ -std=c++11
shmserver:shmserver.cc
	g++ $^ -o $@ -std=c++11
.PHONY:clean
clean:
	rm -rf shmclient shmserver

五、结论

1.共享内存与管道有所不同，如果管道里面没有数据，进程如果想读取管道里面的数据，就会陷入阻塞或直接返回-1（取决于打开文件时候的阻塞和非阻塞）。但当A进程并未输入数据到共享内存里面，而B进程却读取共享内存里面的数据，可能会出现乱码或读取不到任何数据的情况。

2.共享内存效率较高，相比较于管道减少了拷贝次数，原因是共享内存并无缓冲区。

3.共享内存直接通信，管道通过系统调用接口通信。一旦共享内存映射到进程的地址空间，那么该空间直接就被所有进程看到了。

4.共享内存没有保护机制（同步互斥）。

小鳄鱼爱吃薯片
关注
专栏目录
UNIX共享内存总结
nellson的专栏
03-20 1万+
    共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。因此，采用共
Linux 共享内存
06-26
linux华清远见 实验正确代码，共享内存，修改了其中错误的代码。
【Linux】详解IPC：共享内存
最新发布
2301_80171004的博客
08-10 1241
探讨了 Linux 共享内存作为 IPC（进程间通信）技术在操作系统中的重要应用。通过详细介绍共享内存的创建、连接、控制和删除等关键步骤，结合代码示例和实验测试，展示了共享内存如何实现高效、可靠的进程间通信。
linux共享内存
弹-room
11-03 608
共享内存共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。 快速本地通信 因为所有进程共享同一块内存，共享内存在各种进程间通信方式中具有最高的效率。访问共享内存区域和访问进程独有的内存区域一样快，并不需要通过系统
Linux——共享内存
qq_67693066的博客
03-29 1533
Linux——共享内存
VMware虚拟机安装Linux教程(超详细)
10-03
在IT领域，虚拟化技术是不可或缺的一部分，而VMware作为其中的佼佼者，深受广大用户的喜爱。Linux操作系统以其开源、稳定和强大的特性，成为许多开发者和企业的...希望这个超详细的教程能为你的IT之旅开启新的篇章。
【Linux】进程间通信（无名/有名管道及System V共享内存）
学了就忘是正常现象
02-25 1265
无名管道+有名管道+System V共享内存。
Linux系统编程之共享内存
quanshen66的博客
03-06 319
1 共享内存: 在物联内存上开辟一块空间,然后映射到每一个进程逻辑地址空间,多个进程共享同一块内存 注意: 共享内存是进程间通信最快的一种方式 在ubuntu 部分版本中共享内存限制值如下 共享存储区的最小字节数：1 共享存储区的最大字节数：32M 共享存储区的最大个数：4096 每个进程最多能映射的共享存储区的个数：4096 2 共享内存的使用流程 1 创建共享内存 2 在进程中选择一块空间映...
Linux进程间的循环队列内存共享
weixinhum
12-17 2307
上一篇文章我们已经介绍了进程间的内存共享。因为篇幅关系，只是做了简单实现，并不适用于实际应用。因此本篇以实际应用为目的，介绍以循环队列实现的内存共享机制。 该机制可以快速实现数据的先入先出，方便控制内存的大小，减少数据的拷贝次数，且可以方便的选择是数据完整性优先还是实时性优先 实现的原理非常简单，以数据完整性优先为例。我们可以创建如上所示的共享内存，将前面的几个字节定义为信息交流的空间，写...
linux下实现共享内存
01-29
共享内存是linux进程间通信最快的方式，还附有共享内存队列，可以直接用在项目中.
超详细的 linux挂载详解
07-17
- /proc：存放当前系统所有详细信息的目录，信息存储在内存或缓存中。 - /root：系统管理员root用户的家目录。 - /sbin：存放常用程序，但需要管理员权限运行，如格式化磁盘。 - /srv：存放服务所要访问的文件。...
共享内存
diechi0288的博客
07-26 293
效率：采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据[1]： 一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建 立共享内存区域。而是保持共享区...
Linux 共享内存详解一
weixin_33693070的博客
12-26 110
共享内存段被多个进程附加的时候，如果不是所有进程都已经调用shmdt，那么删除该共享内存段时，会出现一个临时的不完整的共享内存段（key值是0），无法彻底删除。只有当所有进程都调用shmdt，这个临时的不完整共享内存段才会消失。 //共享内存 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt...
linux文件目录结构
06-09
Linux文件目录结构一般采用树形结构，根目录为"/"，常见的目录及其作用如下： - /bin：bin是Binary的缩写，这个目录存放着最经常使用的命令。 - /boot：这里存放的是启动Linux时使用的一些核心文件，包括一些连接文件以及镜像文件。 - /dev：dev是Device(设备)的缩写，存放Linux的外部设备，在Linux中访问设备的方式和访问文件的方式类似。 - /etc：这个目录用来存放所有的系统管理所需要的配置文件和子目录。 - /home：用户的主目录，在Linux中，每个用户都有一个自己的目录，一般该目录名是以用户的账号命名的。 - /lib：这个目录里存放着系统最基本的动态连接共享库。 - /lost+found：这个目录一般情况下都是空的，当系统非正常关机而留下“无家可归”的文件时，它们会被放到这里。 - /media：linux系统会自动识别一些设备（如U盘、光驱），当识别后，linux会把识别的设备挂载到这个目录下。 - /mnt：系统提供该目录是为了让用户临时挂载别的文件系统的，我们可以将外部的存储挂载在这个目录下。 - /opt：这是给主机额外安装软件所放置的目录。 - /proc：这个目录是一个虚拟的文件系统，它是系统内存的映射，可以访问很多内核信息。 - /root：该目录为系统管理员，也称作超级权限者的用户主目录。 - /sbin：s就是Super User的意思，这里存放的是系统管理员使用的系统管理程序。 - /tmp：这个目录是用来存放一些临时文件的。 - /usr：这是一个非常重要的目录，用户的很多应用程序和文件都放在这个目录下，类似于windows下的program files目录。 - /var：这个目录中存放着在不断扩充着的东西，习惯将日志文件放在这个目录下。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值