【Linux】共享内存

最新推荐文章于 2024-09-03 19:06:13 发布
最新推荐文章于 2024-09-03 19:06:13 发布
阅读量744 收藏 33
点赞数 20
分类专栏： Linux 文章标签： linux c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48460693/article/details/141601817
版权

目录

原理

代码

在之前，无论是匿名管道还是命名管道，说到底都是基于文件的通信，也就意味着没有为了通信让OS单独设计一套通信模块代码，而是直接复用内核中文件相关的数据结构、缓冲区、代码来实现通信的，这在一定程度上是设计者偷懒，但是也符合我们软件工程尽可能复用代码的思想。除了文件版的通信外，还有人专门为通信从零设计了一套方案，也就是本地通信方案的代码：System V IPC，这套方案有几个典型代表 ：共享内存、消息队列、信号量，但是这种方案由于很多原因已经处于淘汰的边缘了，我们重点需要了解共享内存。

原理

首先，由OS在物理内存为我们①开辟一段内存空间，然后②内存空间通过页表映射到地址空间中的共享区，于是，这段共享区和内存空间构成映射，然后，将共享内存的起始虚拟地址返回给上层用户，用户就可以通过虚拟地址经页表转向共享内存中写内容了，那另一个进程也可以映射这段内存空间。我们把这种用地址空间映射进而能让两个进程看到同一块内存空间的过程叫做共享内存。

对于上面的原理，我们有几点理解：

  • 上面所说的操作，都是OS做的。 
  • OS提供上面的①②步骤的系统调用，供用户进程A、B来进行调用。
  •  共享内存在系统中可以是存在多份的，供不同对进程同时进行通信。
  • OS注定要对共享内存进行管理，先描述，在组织。共享内存不是简单的一段内存空间，也要有描述并管理共享内存的数据结构和匹配的算法。

我们通过  shmget  系统调用创建共享内存，我们来查看一下这个接口的说明：

其中，第二个参数size表示共享内存shm创建多大。第三个参数shmflg是标志位，通过位图的方式来传参，主要选项是IPC_CREAT和IPC_EXCL。IPC_CREAT:如果要创建的共享内存不存在，创建之，如果存在，获取该共享内存并返回，意味着总能获取一个shm；IPC_EXCL:单独使用无意义，只有和IPC_CREAT组合才有意义；IPC_CREAT|IPC_EXCL:如果要创建的共享内存不存在，创建之，如果存在，出错返回 ---- 这个选项组合的意义在于，如果成功返回了，就意味这个shm是全新的。

函数的返回值是共享内存的id。

上面说了这么多，有一个问题是，我（进程）怎么知道OS内共享内存是否存在呢？我们已经知道，共享内存是要有描述自己的数据结构的，而我们必须区分清楚某个共享内存是不是存在，那么我们可以大胆预言一下，共享内存的属性里一定要有标识共享内存唯一性的字段！！所以，我们可以通过共享内存的唯一性标识符判断是不是存在。

为了使另一个进程找到已经创建的共享内存，为此shmget的第一个参数key是由用户形成的，key是多少不重要，只要有唯一性即可！可以通过key来判断这个共享内存是不是存在。 

实际上，OS提供ftok用于生成key。

有了这个调用，这意味我们可以给AB通信的两个进程，使用同样的pathname，同样的proj_id，调用同样的ftok，我们就能形成同样的key了，然后，一个进程创建shm，另一个进程获取shm，就看看到同一个共享内存了。

代码

我们先需要让两个进程得到同一个key，于是我们设计了GetCommonKey函数：

const std::string gpathname = "/home/ghs/linux/linux/lesson22/4.shm";
const int gproj_id = 0x66;

key_t GetCommKey(const std::string& pathname,int proj_id)
{
    key_t k = ftok(pathname.c_str(),proj_id);
    if(k < 0)
    {
        perror("ftok");
    }
    return k;
}

server和client两个进程都调用这个函数，就得到了相同的key：

我们在运行代码的时候，发现，共享内存不随着进程的结束而自动释放！因为共享内存不属于进程，而属于OS。共享内存会一直存在，直到系统重启。需要我们手动释放（指令/其他系统调用）。也就是共享内存的生命周期随内核，文件的生命周期随进程！

我们可以使用指令  ipcs -m  指令查共享内存，

嘿嘿，查到了之前创建的共享内存，然后可以按照 ipcrm -m shmid删除共享内存（而不是按照key删）：

到现在，我们可以对比一下  key  和  shmid，

key：属于用户形成，内核使用的一个字段，用户不能使用key来进行shm的管理。内核进行区分shm唯一性的。（类似struct file*）

shmid：内核给用户返回的一个标识符，用来进行用户级对shm进行管理的id值。（类似fd）

我们创建一个类Shm，

class Shm
{
private:
    key_t GetCommKey()
    {
        key_t k = ftok(_pathname.c_str(), _proj_id);
        if (k < 0)
        {
            perror("ftok");
        }
        return k;
    }
    int GetShmHelper(key_t key, int size, int flag)
    {
        int shmid = shmget(key, size, flag);
        if (shmid < 0)
        {
            perror("shmget");
        }
        return shmid;
    }

public:
    Shm(const std::string &pathname, int proj_id, int who)
        : _pathname(pathname), _proj_id(proj_id), _who(who)
    {
        _key = GetCommKey();
        if(_who == gCreater) GetShmUseCreate();
        else if(_who == gUser) GetShmForUse();

        std::cout << "shmid: " << _shmid << std::endl;
        std::cout << "key: " << ToHex(_key) << std::endl;
    }
    ~Shm() {}

    std::string ToHex(key_t key)
    {
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "0x%x", key);
        return buffer;
    }
    bool GetShmUseCreate()
    {
        if (_who == gCreater)
        {
            _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL);
            if (_shmid >= 0)
                return true;
        }
        return false;
    }
    bool GetShmForUse()
    {
        if (_who == gUser)
        {
            _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT);
            if (_shmid >= 0)
                return true;
        }
        return false;
    }

private:
    key_t _key;
    int _shmid;
    std::string _pathname;
    int _proj_id;
    int _who;
};

server和client分别创建一个shm对象，

它们找到了同一块共享内存。

那么，我们怎么删除共享内存呢？其实，我们可以使用  shmctl  接口调用，

既然叫*ctl，那么它不仅可以删除shm，还可以做其他的操作（比如获取属性），cmd的选项为IPC_RMID时可以删除shm，因此，我们在析构函数中加入删除shm的操作。

现在，我们已经可以创建好共享内存，接下来就是让共享内存通过页表映射到地址空间（挂接到进程），那共享内存该如何挂接呢？有一个系统调用接口  shma(at-attach) ，还有一个调用时shmdt(dt-detach，去关联)：

shmat：其中，shmid就是我们自己申请的共享内存。shmaddr就是我们想挂接到哪个地址上，但是现在我们不考虑，设为null。shmflg就是设置共享内存的访问权限，在这里我们设置为读写，设为0即可。那么其返回值void*是什么呢？其实是地址空间中共享内存的起始地址，这点和malloc很相似，malloc返回堆上开辟空间的起始地址。

shmdt：去挂接，shmaddr为shmat的返回值。 

接下来我们开始挂接共享内存：

void* AttachShm()
{
    void* shmaddr = shmat(_shmid,nullptr,0);
    if(shmaddr == nullptr)
    {
        perror("shmat");
    }
    std::cout << "who: " << RoleToString(_who) << " attach shm..." << std::endl;
    return shmaddr;
}
void DetachShm(void* addr)
{
    if(addr == nullptr) return;
    shmdt(addr);
    std::cout << "who: " << RoleToString(_who) << " detach shm..." << std::endl;
}

可以看到，server和client依次运行，先挂接后去挂接，共享内存的挂接数由0->1->2->1->0。

到此，别看我们做了很多，但是我们还没有开始通信！！根本原因在于我们是进程间通信，我们之前的工作只能叫通信的准备工作。

现在我们开始通信：

我们的server.cc是：

int main()
{
    Shm shm(gpathname,gproj_id,gCreater);
    char* addr = (char*)shm.Addr();

    while(true)
    {
        std::cout << "shm memory content: " << addr << std::endl;
        sleep(1);
    }

    return 0;
}

我们的client.cc是：

int main()
{
    Shm shm(gpathname,gproj_id,gUser);
    shm.Zero(); 
    char* addr = (char*)shm.Addr();
    sleep(3);
   
   //当成string
   char ch = 'A';
   while(ch <= 'Z')
   {
       addr[ch - 'A'] = ch;
       ch++;
       sleep(2);
   }
    return 0;
}

我们先运行server，发现server一直在读，

并没有阻塞在这里，然后，运行client，写数据，

这里两秒读一次，我们很奇怪的发现，第一次读完之后，第二次还可以读到一样的数据，这是因为共享内存不提供对共享内存的任何保护机制，这样可能导致我还没写完就被读走了，会导致数据不一致问题。其次，我们在访问共享内存的时候，没有用任何系统调用，所以，共享内存是所有进程IPC，速度最快的，因为，共享内存大大减少了数据内存的拷贝次数。那么，怎么对共享内存施加保护呢？当共享内存中没有数据时就不要读，等有数据的时候并且我想让你读的时候你再读！我们之前已经知道，管道是存在同步机制的，所以，server和client除了建立共享内存外，还要建立管道，server在从共享内存中读数据前，先去读管道，管道没数据的话，server就等着。当client写完数据后，通过管道通知server再来读，这不就完成了对共享内存的保护了吗？

在上面，我们设置了共享内存的大小是4096，我们建议其大小是4096*n，

 我们如何获取共享内存的属性呢？需要使用shmctl调用，

 shmctl的第二个参数我们设置成IPC_STAT，就可以获取共享内存的属性信息了。

void DebugShm()
{
    struct shmid_ds ds;
    int n = shmctl(_shmid, IPC_STAT, &ds);
    if(n < 0) return;
    std::cout << "ds.shm_perm.__key :" << ToHex(ds.shm_perm.__key) << std::endl;
    std::cout << "ds.shm_nattch"<< ds.shm_nattch << std::endl;
}

关于共享内存，这里有两点需要着重强调：

  1. 共享内存的key是在用户层面生成的，需要两个进程使用同一个算法生成相应的key。
  2. 两个进程，一个用来创建，一个用来获取，这和命名管道类似。

完整代码见下面：

Shm.hpp

#ifndef __SHM_HPP__
#define __SHM_HPP__

#include <iostream>
#include <cstdio>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

const int gCreater = 1;
const int gUser = 2;
const std::string gpathname = "/home/ghs/linux/linux/lesson22/4.shm";
const int gproj_id = 0x66;
const int gShmSize = 4096;

class Shm
{
private:
    key_t GetCommKey()
    {
        key_t k = ftok(_pathname.c_str(), _proj_id);
        if (k < 0)
        {
            perror("ftok");
        }
        return k;
    }
    int GetShmHelper(key_t key, int size, int flag)
    {
        int shmid = shmget(key, size, flag);
        if (shmid < 0)
        {
            perror("shmget");
        }
        return shmid;
    }

    std::string RoleToString(int who)
    {
        if (who == gCreater)
            return "Creater";
        else if (who == gUser)
            return "User";
        else
            return "None";
    }

    void *AttachShm()
    {
        if (_shmaddr != nullptr)
            DetachShm(_shmaddr);
        void *shmaddr = shmat(_shmid, nullptr, 0);
        if (shmaddr == nullptr)
        {
            perror("shmat");
        }
        std::cout << "who: " << RoleToString(_who) << " attach shm..." << std::endl;
        return shmaddr;
    }
    void DetachShm(void *addr)
    {
        if (addr == nullptr)
            return;
        shmdt(addr);
        std::cout << "who: " << RoleToString(_who) << " detach shm..." << std::endl;
    }

public:
    Shm(const std::string &pathname, int proj_id, int who)
        : _pathname(pathname), _proj_id(proj_id), _who(who), _shmaddr(nullptr)
    {
        _key = GetCommKey();
        if (_who == gCreater)
            GetShmUseCreate();
        else if (_who == gUser)
            GetShmForUse();
        _shmaddr = AttachShm();
        std::cout << "shmid: " << _shmid << std::endl;
        std::cout << "key: " << ToHex(_key) << std::endl;
    }
    ~Shm()
    {
        if (_who == gCreater)
        {
            int res = shmctl(_shmid, IPC_RMID, nullptr);
        }
        std::cout << "shm remove done..." << std::endl;
    }

    std::string ToHex(key_t key)
    {
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "0x%x", key);
        return buffer;
    }
    bool GetShmUseCreate()
    {
        if (_who == gCreater)
        {
            _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL | 0666);
            if (_shmid >= 0)
            {
                std::cout << "shm create done..." << std::endl;
                return true;
            }
        }
        return false;
    }
    bool GetShmForUse()
    {
        if (_who == gUser)
        {
            _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | 0666);
            if (_shmid >= 0)
            {
                std::cout << "shm use done..." << std::endl;
                return true;
            }
        }
        return false;
    }
    void *Addr()
    {
        return _shmaddr;
    }
    void Zero()
    {
        if(_shmaddr)
        {
            memset(_shmaddr,0,gShmSize);
        }
    }
    void DebugShm()
    {
        struct shmid_ds ds;
        int n = shmctl(_shmid, IPC_STAT, &ds);
        if(n < 0) return;
        std::cout << "ds.shm_perm.__key :" << ToHex(ds.shm_perm.__key) << std::endl;
        std::cout << "ds.shm_nattch"<< ds.shm_nattch << std::endl;
    }

private:
    key_t _key;
    int _shmid;
    std::string _pathname;
    int _proj_id;
    int _who;
    void *_shmaddr;
};

#endif

namedPipe.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstdio>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define Creater 1
#define User 2
#define BaseSize 4096
#define DefaultFd -1
#define Read O_RDONLY
#define Write O_WRONLY

const std::string comm_path = "./myfifo";

class NamedPipe
{
private:
    bool OpenNamedPipe(int mode)
    {
        _fd = open(_fifo_path.c_str(), mode);
        if (_fd < 0)
            return false;
        return true;
    }
public:
    NamedPipe(const std::string &path, int who)
        : _fifo_path(path), _id(who), _fd(DefaultFd)
    {
        if (who == Creater)
        {
            int res = mkfifo(path.c_str(), 0666);
            if (res < 0)
            {
                perror("mkfifo");
            }
            std::cout << "creater create named pipe" << std::endl;
        }
    }
    bool OpenForRead()
    { 
        return OpenNamedPipe(Read);
    }
    bool OpenForWrite()
    {
        return OpenNamedPipe(Write);
    }
    int ReadNamedPipe(std::string* out)
    {
        char buffer[BaseSize];
        int n = read(_fd, buffer, sizeof(buffer));
        if(n > 0)
        {
            buffer[n] = 0;
            *out = buffer;
        }
        return n;
    }
    int WriteNamedPipe(const std::string& in)
    {
        return write(_fd, in.c_str(), in.size());
    }

    ~NamedPipe()
    {
        if (_id == Creater)
        {
            //sleep(5);
            int res = unlink(_fifo_path.c_str());
            if (res < 0)
            {
                perror("unlink");
            }
            std::cout << "creater free named pipe" << std::endl;
        }
        if(_fd != DefaultFd) close(_fd);
    }

private:
    const std::string _fifo_path;
    int _id;
    int _fd;
};

server.cc

#include "Shm.hpp"
#include "namedPipe.hpp"

int main()
{
    //1.创建共享内存
    Shm shm(gpathname,gproj_id,gCreater);
    char* addr = (char*)shm.Addr();

    shm.DebugShm();
    // //2.创建管道
    // NamedPipe fifo(comm_path, Creater);
    // fifo.OpenForRead();

    // while(true)
    // {
    //     std::string temp;
    //     fifo.ReadNamedPipe(&temp);
    //     std::cout << "shm memory content: " << addr << std::endl;
    // }

    return 0;
}

client.cc

#include "Shm.hpp"
#include "namedPipe.hpp"

int main()
{
    //1.创建共享内存    
    Shm shm(gpathname,gproj_id,gUser);
    shm.Zero(); 
    char* addr = (char*)shm.Addr();
    sleep(3);

    //2.打开管道
    NamedPipe fifo(comm_path, User);
    fifo.OpenForWrite();
   
   //当成string
   char ch = 'A';
   while(ch <= 'Z')
   {
       addr[ch - 'A'] = ch;
       std::string temp = "wakeup";
       std::cout << "add " << ch << " into Shm, " << "wake up reader" << std::endl;
       fifo.WriteNamedPipe(temp);
       ch++;
       sleep(2);
   }
    return 0;
}
核动力C++选手
关注
  • 20
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Linux共享内存
C语言实战技术
03-05 818
文章目录一、共享内存的概念二、相关函数1、shmget函数2、shmat函数3、shmdt函数4、shmctl函数三、示例程序四、其它的操作命令在这里插入图片描述 五、版权声明 一、共享内存的概念 共享内存（Shared Memory）就是允许多个进程访问同一个内存空间，是在多个进程之间共享和传递数据最高效的方式。操作系统将不同进程之间共享内存安排为同一段物理内存，进程可以将共享内存连接到它们自己...
Linux共享内存实现机制的详解
01-20
Linux共享内存实现机制的详解 内存共享： 两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一...
Linux 共享内存
小灰灰的博客
07-07 2577
创建共享内存：在Linux系统中，可以使用shmget函数来创建一个共享内存标识符。该函数需要指定共享内存的大小、权限等参数，并返回一个唯一的标识符。连接共享内存：使用shmat函数将进程与共享内存进行连接，该函数需要传入共享内存标识符和一个用户指定的地址，如果地址为0，则由系统选择一个可用的地址。使用共享内存：连接成功后，进程可以像使用普通内存一样使用共享内存，通过读写共享内存实现进程间的数据交换。分离共享内存：使用shmdt函数将进程与共享内存分离，分离后进程不能再访问共享内存。
linux共享内存
qq_54075859的博客
08-31 2059
共享内存概念： ；获取或申请共享内存 ；映射共享内存到进程的虚拟空间 ；解除映射 ；删除共享内存：
linux 共享内存 shmget
一个追逐梦想的码农
04-04 2319
本专栏主要分享linux下并发编程相关知识，包括多进程，多线程，进程/线程间通信，并发同步控制，以及高并发下性能提升，请大家多多留言。共享内存是进程间通信的一种常用手段，相较于其它通信方法，它可以在进程间传递大量的不同格式的数据，同时这些数据不需要持久保存在磁盘上。
linux 共享内存问题
weixin_50208491的博客
04-19 840
之前遇到共享内存的错误，然后查了很多不知道该怎么解决。最后终于一点点拼凑起来解决了问题。 首先可以通过ipcs -m 查看共享内存有哪些； 然后通过ipcs -m -p查看创建的pid看看是否是因为共享内存没关闭的问题导致的。 用ipcs 命令不仅可以看到消息队列还可以看到信号量组 我遇到的问题是就是processmanager会申请一个共享内存，关闭的这个组件的时候并不会关闭开辟的共享内存，下一次如果用root启动了他还会使用原来的信号量数组但是拥有者会改成root，再用a8014启动的话就无法启动p.
Linux共享内存实验的5个头文件
10-25
自己整理的Linux5个共享内存头文件， 通过编写共享内存实验，进一步了解使用共享内存的具体步骤，同时加深对共享内存的理解。在本实验中，采用信号量作为同步机制完善两个进程(“生产者”和“消费者”)之间的通信。
linux 共享内存
09-16
概述 注意事项 软件包的来源 安装软件包需要注意的问题 编译程序 编译和安装 更多的资料 安装到系统中的文件
【运维监控】prometheus+node exporter+grafana 监控linux机器运行情况（2）
alanchanchn的专栏
09-03 1213
本示例是通过prometheus的node exporter收集主机的信息，然后在grafana的dashborad进行展示。本示例使用到的组件均是最新的，下文中会有具体版本说明，linux环境是centos。本示例分为四个部分，即prometheus、grafana、node exporter的部署和三者集成的监控linux。本文旨在说明三者如何使用，不涉及各自组件的介绍，如果需要使用到本文的，肯定都有了解。
Linux字符设备驱动 -- regulator子系统
xi_xix_i的博客
09-01 735
Linux驱动之Regulator子系统Linux 内核之电源篇(加载流程)regulator，翻译就是调节器。一些可以输出电流电压的设备可以使用该子系统。举个例子，一个PMIC有多路输出，每一路输出都可以给很多外设、芯片供电。那么每一路输出，我都可以认为他是一个regulator。
在linux 中如何将.c 文件转换为可执行文件
千千道的博客
08-29 1754
在 Linux 环境下进行 C 语言编程时，将.c文件转换为可执行文件是一个关键的步骤。这个过程涉及到使用编译器和一些相关的工具，本文将详细介绍在 Linux 系统中如何将.c文件转换为可执行文件的方法。
实时Linux性能监控脚本：周期性自动统计CPU、内存和IO使用情况
promise524的博客
08-30 945
Shell脚本实现每3秒钟监控系统的 CPU 占用率、内存使用情况、IO使用情况、每个 CPU 核心的占用率、CPU 占用率最高的前10个进程以及/opt目录的磁盘空间变化。
linux查找mysql日志
爱思考的People
08-30 555
MySQL的日志文件通常存储在数据库服务器的数据目录下，具体位置取决于MySQL的配置文件。# 查找MySQL配置文件# 查找MySQL日志文件。
解决bug: RuntimeError: Address already in use，一个linux下pytorch多卡训练tcp端口占用的bug
最新发布
beneficial的博客
09-03 165
时间：2024.9.3。
Linux下IO多路复用—select，poll，epoll
热土程序园，利他愉己~
08-29 1457
Linux下IO多路复用—select，poll，epoll IO多路复用是一种操作系统的技术，用于在单个线程或进程中管理多个输入输出操作。它的主要目的是通过将多个IO操作合并到一个系统调用中来提高系统的性能和资源利用率，避免了传统的多线程或多进程模型中因为阻塞IO而导致的资源浪费和低效率问题。 在IO多路复用中，通常使用的系统调用有 select()、poll()、epoll() 等，它们允许程序等待多个文件描述符（sockets、文件句柄等）中的任何一个变为可读或可写，然后再进行实际的IO操作。
linux nc
xiaozhi
09-03 330
linux nc
[Linux] 项目自动化构建工具-make/Makefile
水墨不写bug
09-03 687
[Linux] 项目自动化构建工具-make/Makefile
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值