Linux使用System V实现内存共享的最佳实践

· 日常编程 · 264726

System V的共享内存是Unix操作系统中一种进程间通信机制,它允许不同的进程通过共享一块物理内存区域来交换数据,共享内存提供了高效的进程间通信方式,因为进程可以直接读写共享区域,本文给大家介绍了在Linux上实现内存共享的最佳实践,需要的朋友可以参考下

目录
  • 前言：
  • system V共享内存
    • System V共享内存的特点：
    • System V共享内存流程：
    • system V共享内存函数：
      • 1. shmget
      • 2. shmat
      • 3. shmdt
      • 4. shmctl
      • 5.ftok
      • shmid_ds结构体
      • 代码的工作流程：
      • 总结
  • 共享内存通信实例（管道控制同步）
    • 1. 构建管道类
      • 2. 获取key值
        • 3.创建共享内存段
          • 4.映射、使用和销毁共享内存
            • 服务端：
            • 客户端：

        前言：

        System V的共享内存是Unix操作系统中一种进程间通信（IPC）机制，它允许不同的进程通过共享一块物理内存区域来交换数据。共享内存提供了高效的进程间通信方式，因为进程可以直接读写共享区域，而不需要通过内核或其他进程的中介。

        system V共享内存

        System V共享内存的特点：

        1. 高效性：通过共享内存，不同进程可以直接访问和修改数据，而不需要经过数据复制的过程，减少了开销。
        2. 持久性：共享内存段在进程退出后仍然存在，直到显式地由进程删除。
        3. 权限控制：共享内存段可以设定访问权限，控制哪些进程可以读写共享内存。

        System V共享内存流程：

        1. 获取key值：进程通过ftok系统调用来计算出key值.
        2. 创建共享内存段：进程使用 shmget 系统调用来创建或访问共享内存段。
        3. 映射共享内存：通过 shmat 系统调用，将共享内存段映射到进程的虚拟地址空间中。
        4. 使用共享内存：进程可以直接通过指针访问共享内存，就像访问普通内存一样。
        5. 解除映射：进程使用 shmdt 来解除对共享内存段的映射。
        6. 删除共享内存：当不再需要共享内存时，进程通过 shmctl 来删除共享内存段。

        system V共享内存函数：

        在Unix系统中，System V共享内存的操作由一系列系统调用来管理。以下是常用的共享内存函数：

        1. shmget

        功能：创建一个共享内存段或获取已经存在的共享内存段。

        原型：

        int shmget(key_t key, size_t size, int shmflg);

        返回值：返回共享内存段的标识符（一个非负整数），如果出错，返回 -1。

        • key：共享内存段的键值，用于标识共享内存。如果是新创建的共享内存段，key是唯一的。
        • size：共享内存段的大小（字节数）。
        • shmflg：标志位，控制共享内存的访问权限。常用标志有：
          • IPC_CREAT：如果共享内存段不存在，则创建一个新段。
          • IPC_EXCL：与IPC_CREAT一起使用，如果共享内存段已存在则调用失败。
          • 0666：设置权限（可读可写）。

        2. shmat

        功能：将共享内存段映射到进程的虚拟地址空间。

        原型：

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

        返回值：返回共享内存的指针（映射到进程地址空间中）。如果失败，则返回(void*) -1。

        • shmid：由shmget返回的共享内存段标识符。
        • shmaddr：期望的映射地址，通常设置为NULL，让操作系统自动选择地址。
        • shmflg：标志位，常用的标志是0（表示默认映射），SHM_RDONLY（只读映射）。

        3. shmdt

        功能：解除共享内存的映射。

        原型：

        int shmdt(const void *shmaddr);

        返回值：成功返回0，失败返回-1。

        • shmaddr：共享内存的指针，通常是由shmat返回的指针。

        4. shmctl

        功能：控制共享内存段的各种操作，例如获取共享内存段的状态、删除共享内存段等。

        原型：

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

        返回值：成功返回0，失败返回-1。

        • shmid：共享内存段的标识符。
        • cmd：控制命令，常用的命令有：
          • IPC_STAT：获取共享内存段的状态。
          • IPC_RMID：删除共享内存段。
          • SHM_INFO：获取共享内存的统计信息。
        • buf：用于存储共享内存信息的结构体，shmid_ds结构体定义了共享内存的状态信息。

        5.ftok

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

        参数：

        • pathname：文件路径名（文件或目录的路径），该文件必须存在且具有一定的权限。路径名用于生成一个唯一的标识符。
        • proj_id：一个项目标识符，通常是一个字符值（例如 ‘A’、‘B’ 等）。这用于区分同一文件的不同用途。

        返回值：

        • 成功时返回一个 key_t 类型的唯一键值，可以用于标识 IPC 对象。
        • 失败时返回 -1，并设置 errno 为相应的错误代码。

        shmid_ds结构体

        shmctl函数返回的shmid_ds结构体用于获取共享内存段的信息。它通常包含以下字段：

        struct shmid_ds {
    struct ipc_perm shm_perm;  // 权限
    size_t shm_segsz;          // 共享内存段大小
    time_t shm_atime;          // 最近一次附加时间
    time_t shm_dtime;          // 最近一次分离时间
    time_t shm_ctime;          // 创建时间
    pid_t shm_cpid;            // 创建该共享内存段的进程ID
    pid_t shm_lpid;            // 最后操作该共享内存段的进程ID
    shmatt_t shm_nattch;       // 附加到共享内存的进程数
};

        观察shmif_ds结构体

        #include"share.hpp"  // 引入头文件，假设这是包含共享内存相关函数声明的头文件。

using namespace std;  // 使用标准命名空间，简化代码书写。

int main()
{
    // 获取共享内存段的标识符
    int shmid = Getshmid();  
    // 使用shmat函数将共享内存映射到进程的地址空间
    char* shaddr = (char*)shmat(shmid, nullptr, 0);  
    // 定义一个shmid_ds结构体，用于存储共享内存段的状态信息
    struct shmid_ds shmds;
    
    // 调用shmctl函数获取共享内存段的状态
    int ret = shmctl(Getshmid(), IPC_STAT, &shmds);  
    // 输出共享内存的权限
    cout << "权限: " << shmds.shm_perm.mode << endl;
    // 输出共享内存的大小（字节数）
    cout << "共享内存大小: " << shmds.shm_segsz << endl;
    // 输出创建共享内存的进程ID
    cout << "创建共享内存的进程ID: " << shmds.shm_perm.mode << endl;
    // 输出共享内存的key值以及当前程序自定义的key值
    cout << "共享内存的key值: " << shmds.shm_perm.__key << "  自己创建的值：" << Get_key() << endl;
    
    // 使用shmdt解除共享内存的映射
    shmdt((void*)shaddr);

    return 0;  // 结束程序
}

        代码的工作流程：

        1. 获取共享内存标识符 (shmid)：通过Getshmid()获取共享内存的标识符。Getshmid()应该是用户自己定义的一个函数，返回有效的共享内存段ID。
        2. 映射共享内存：通过shmat函数将共享内存段映射到当前进程的地址空间。这里使用的是nullptr，表示操作系统会自动选择一个合适的地址来映射共享内存。
        3. 获取共享内存信息：调用shmctl函数并使用IPC_STAT命令来获取共享内存段的状态，保存在shmid_ds结构体中。这个结构体包含了共享内存的权限、大小、创建进程ID、key值等信息。
        4. 输出共享内存的信息：输出共享内存的权限、大小、创建进程ID以及key值。注意，在输出创建共享内存的进程ID时，代码中有个小错误，应改为shmds.shm_cpid，而不是shmds.shm_perm.mode，因为mode字段是权限信息。
        5. 解除共享内存映射：调用shmdt函数解除映射，防止进程泄露资源。

        总结

        • shmget用于创建和访问共享内存段。
        • shmat用于将共享内存段映射到进程的地址空间。
        • shmdt用于解除共享内存的映射。
        • shmctl用于控制共享内存段，例如删除或查看信息。

        共享内存通信实例（管道控制同步）

        1. 构建管道类

        class FIFO
{
public:
    // 构造函数：创建命名管道（FIFO）
    FIFO()
    {
        // 调用 mkfifo 创建命名管道，MYFIFO_PATH 是管道的路径，MODE 是文件权限
        int n = mkfifo(MYFIFO_PATH, MODE);
        
        // 检查 mkfifo 是否成功，若返回值为 -1，则表示创建失败
        if (n == -1)
        {
            // 如果创建失败，记录错误日志并退出程序
            log(fatal, "mkfifo failure: %s", strerror(errno));  // 输出错误日志，显示错误原因
            exit(4);  // 返回 4 表示创建管道失败
        }
        
        // 如果创建成功，记录成功日志
        log(info, "mkfifo success");  // 输出成功日志
    }

    // 析构函数：删除命名管道
    ~FIFO()
    {
        // 调用 unlink 删除命名管道
        int n = unlink(MYFIFO_PATH);
        
        // 检查 unlink 是否成功，若返回值为 -1，则表示删除失败
        if (n == -1)
        {
            // 如果删除失败，记录错误日志并退出程序
            log(error, "unlink failure: %s", strerror(errno));  // 输出错误日志，显示错误原因
            exit(4);  // 返回 4 表示删除管道失败
        }
        
        // 如果删除成功，记录成功日志
        log(info, "unlink success");  // 输出成功日志
    }
};

        FIFO 类用于创建和删除命名管道（FIFO）。

        构造函数：在对象创建时，调用 mkfifo 创建命名管道。如果创建失败，记录错误并退出程序。

        析构函数：在对象销毁时，调用 unlink 删除命名管道。如果删除失败，记录错误并退出程序。

        2. 获取key值

        • 获取key值：进程通过ftok系统调用来计算出key值.
        key_t GetKey()
{
    // 调用 ftok 函数，使用 pathname 和 proj_id 生成唯一的 IPC 键值
    key_t key = ftok(pathname.c_str(), proj_id);    
    // 检查 ftok 调用是否成功，key < 0 表示失败
    if (key < 0)
    {
        // 如果 ftok 失败，记录错误信息到日志，并返回 1
        log(fatal, "ftok failure:%s", strerror(errno)); // 错误日志输出，显示 errno 对应的错误信息
        return 1; // 返回 1 表示错误
    }
    // 如果成功，记录成功信息到日志
    log(info, "GetKey success"); // 成功日志输出
    // 返回生成的唯一 IPC 键值
    return key;

        3.创建共享内存段

        • 创建共享内存段：进程使用 shmget 系统调用来创建或访问共享内存段。
        int GetShare_mm(int flag)
{
    // 使用获取的 IPC 键值（通过 GetKey 函数）和共享内存的大小（SIZE_MM）来调用 shmget 创建或获取共享内存
    int shmid = shmget(GetKey(), SIZE_MM, flag);
    
    // 检查 shmget 调用是否成功，如果返回值是 -1 表示创建或获取共享内存失败
    if (shmid == -1)
    {
        // 如果 shmget 失败，记录错误信息到日志，并返回 2 作为错误标识
        log(fatal, "shmget failure: %s", strerror(errno)); // 错误日志输出，显示 errno 对应的错误信息
        return 2; // 返回 2 表示共享内存获取失败
    }
    // 如果 shmget 成功，记录成功信息到日志
    log(info, "shmget success"); // 成功日志输出
    // 返回获取的共享内存标识符
    return shmid;
}

        4.映射、使用和销毁共享内存

        服务端：

        int main()
{
    // 创建一个命名管道 FIFO
    FIFO init;  // 假设 FIFO 是一个类，它的构造函数用于初始化命名管道。

    // 打开命名管道，打开模式是只读
    int fd = open("myfifo", O_RDONLY);
    if (fd == -1)
    {
        // 如果打开管道失败，记录错误并退出
        log(error, "open failure: %s", strerror(errno)); // 错误日志输出，显示 errno 对应的错误信息
        exit(5); // 返回 5 表示出现错误并退出
    }

    // 创建共享内存并获取共享内存标识符
    int shmid = CreateShmid();  // 假设 CreateShmid() 是创建共享内存的函数，它返回共享内存段的标识符。

    // 将共享内存映射到进程的地址空间
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    if ((void*)shmaddr == (void*)-1)
    {
        // 如果共享内存映射失败，记录错误并返回
        log(fatal, "shmat failure: %s", strerror(errno)); // 错误日志输出
        return 1; // 返回 1 表示出错
    }

    // 进入通信循环
    while (true)
    {
        char ch;
        • 创建管道：使用 FIFO 类创建命名管道。
        • 打开管道：调用 open("myfifo", O_RDONLY) 打开管道进行读取。如果失败，记录错误并退出。
        • 创建共享内存：使用 CreateShmid() 创建共享内存。、
        • 映射共享内存：使用 shmat() 将共享内存映射到进程地址空间，检查映射是否成功。
        • 通信循环：从管道读取字符，输出共享内存内容，直到读取结束。
        • 解除映射与清理：使用 shmdt() 解除共享内存映射，调用 DeleteShare() 删除共享内存，释放资源。

        客户端：

        #include "share.hpp"

int main()
{
    // 打开命名管道 "myfifo" 进行写操作 (O_WRONLY)
    int fd = open("myfifo", O_WRONLY);
    if (fd == -1)  // 如果打开管道失败，fd 会是 -1
    {
        // 记录管道打开失败的错误信息并退出程序
        log(error, "open failure: %s", strerror(errno)); 
        exit(5);  // 退出程序，返回错误码 5
    }
    // 获取共享内存的标识符
    int shmid = Getshmid();

    // 将共享内存映射到进程地址空间
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    if ((void*)shmaddr == (void*)-1)  // 检查映射是否成功
    {
        // 如果映射失败，记录错误信息并退出程序
        log(fatal, "shmat failure: %s", strerror(errno));
        return 1;  // 返回错误码 1
    }
    // 进入通信循环
    while (true)
    {
        // 提示用户输入
        std::cout << "Please Enter@ ";
        // 从标准输入读取数据并存储到共享内存
        fgets(shmaddr, SIZE_MM, stdin);  

        // 向管道写入字符 'x'，表示有新的消息
        int n = write(fd, "x", sizeof(char));  
    }
    // 解除共享内存映射
    shmdt((void*)shmaddr);
    return 0;  // 正常退出
}
        • 打开管道：通过 open("myfifo", O_WRONLY) 打开管道进行写操作。如果失败，记录错误并退出。
        • 获取共享内存：使用 Getshmid() 获取共享内存标识符，使用 shmat() 将共享内存映射到进程地址空间。
        • 通信循环：不断提示用户输入，将用户输入存储到共享内存中，并向管道写入字符 'x' 表示有新的数据。、
        • 解除映射并退出：调用 shmdt() 解除共享内存映射，程序正常退出。

        以上就是Linux使用System V实现内存共享的最佳实践的详细内容，更多关于Linux System V内存共享的资料请关注骃骐网其它相关文章！

        您可能感兴趣的文章:

        • Linux之systemV共享内存方式
        • 解决Linux system v 共享内存问题
        • Linux中的systemd与SysVinit使用
        • Linux systemV消息队列和信号量详解
        • Linux中的service命令与systemctl命令有何区别

        相关推荐：

        为什么Python程序占用内存持续升高不释放_使用memory_profiler进行环境监控

        memory_profiler仅统计每行新分配内存，不追踪对象生命周期或引用链，适合定位单次执行的内存尖峰，而非长周期泄漏；真正卡住内存的是强引用未释放，需用gc.get_referrers()或objgraph分析。 内存持续升高不释放，大概率不是“没回收”，而是对象还在被强引用着——memory_profiler能帮你看到哪行代码在吃内存，但不能告诉你谁在死死拽着它不放。 为什么memory_...

        Python开发FastAPI怎么实现WebSocket在线人数统计_基于内存字典或Redis维护连接池

        FastAPI中需用可哈希标识（如id(websocket)或user_id）增减在线人数，内存方案须加锁防竞态，多进程必须用Redis原子指令incr/decr维护共享计数，并配合心跳键实现高可用。 WebSocket连接建立时怎么安全地增减在线人数 FastAPI的WebSocket实例没有唯一ID，直接用websocket对象做字典键会报TypeError: unhashable type:...

        Python怎么避免Flask应用遭遇内存溢出_控制大文件内存载入与及时显式del释放

        应避免大文件读取时调用.read()等一次性加载方法，改用分块读取、流式处理、临时文件磁盘存储及作用域隔离，并通过MAX_CONTENT_LENGTH限制上传大小、禁用全局缓存、谨慎记录日志来防止内存溢出。 大文件读取时直接用 open().read() 会爆内存 Flask 默认没有请求体大小限制，用户上传一个 500MB 的文件，如果你写 request.files['file'].read(...

        如何在Raspberry Pi上配置Python 3开发环境_优化内存占用与库安装

        树莓派pip安装常卡在“Building wheel”阶段，因ARM架构编译资源有限、默认swap仅100MB，编译大库易OOM导致假死；需增大swap、换清华源（含apt主源、raspi.list和pip.conf）、优先用apt装预编译包（如sudo apt install python3-opencv），或强制二进制安装。 树莓派上直接用系统自带的 Python 3 就能跑基础脚本，但想稳定...

        Python类中正确实现列表随机打乱的实践指南

        在Python类初始化时直接对传入列表调用random.shuffle()会导致多个实例共享同一份被修改的数据，根本原因是未创建独立副本；解决方法是使用.copy()或list()构造新列表后再打乱。 在python类初始化时直接对传入列表调用`random.shuffle()`会导致多个实例共享同一份被修改的数据，根本原因是未创建独立副本；解决方法是使用`.copy()`或`list()`构造新...

        Python 文件组织与播放列表优化实践指南

        本文探讨在 python 音乐点唱机（jukebox）应用中，如何高效组织和加载 wav 歌曲文件：对比基于文本配置文件的分组方案与基于文件名编码的隐式分组方案，并提供可落地的代码实现与性能建议。 本文探讨在 python 音乐点唱机（jukebox）应用中，如何高效组织和加载 wav 歌曲文件：对比基于文本配置文件的分组方案与基于文件名编码的隐式分组方案，并提供可落地的代码实现与性能建议。 在构...

        JSON可序列化对象的类型标注最佳实践

        本文介绍如何为接受任意JSON可序列化输入的函数设计精确、安全且符合mypy规范的类型提示，解决Union[List[Any], Dict[Any, Any]]不完整、禁用Any及递归类型声明等核心问题。 本文介绍如何为接受任意json可序列化输入的函数设计精确、安全且符合mypy规范的类型提示，解决`union[list[any], dict[any, any]]`不完整、禁用`any`及递归类...

        JSON序列化安全类型的精准类型标注实践

        本文介绍如何为支持json.dumps的函数参数设计严谨、可静态检查的类型提示，解决Union[List[Any], Dict[Any, Any]]不完整且违反mypy规范的问题，推荐使用递归TypeAlias定义完整的JSON可序列化类型。 本文介绍如何为支持`json.dumps`的函数参数设计严谨、可静态检查的类型提示，解决`union[list[any], dict[any, any]]`...

        JSON可序列化对象的类型定义最佳实践

        本文介绍如何为接受任意json可序列化输入的python函数编写精确、安全且mypy友好的类型注解，涵盖递归类型别名的定义、使用方式及注意事项。 本文介绍如何为接受任意json可序列化输入的python函数编写精确、安全且mypy友好的类型注解，涵盖递归类型别名的定义、使用方式及注意事项。 在Python中，json.dumps() 能处理的值类型并非无限宽泛，而是严格限定于以下几类：None、布...

        Python pytest怎么对大型项目进行目录组织_遵循src与tests分离最佳实践

        必须将tests/与src/置于项目根目录平级，否则会导致import失败、路径混乱及CI崩溃；因pytest默认仅将当前目录加入sys.path，src不在其中则无法解析myapp模块，且易误导入已安装旧包而非正在开发的源码。 必须把 tests/ 和 src/ 放在项目根目录下平级，否则 import 会错、路径会乱、CI 会挂。 为什么不能把 tests 塞进 src 里 常见错误是建出 s...