System V共享内存详解:在Linux上实现内存共享的最佳实践

发布于:2025-03-17 ⋅ 阅读:(11) ⋅ 点赞:(0)

个人主页:chian-ocean

文章专栏-Linux

前言:

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);
    
    • key:共享内存段的键值,用于标识共享内存。如果是新创建的共享内存段,key是唯一的。
    • size:共享内存段的大小(字节数)。
    • shmflg:标志位,控制共享内存的访问权限。常用标志有:
      • IPC_CREAT:如果共享内存段不存在,则创建一个新段。
      • IPC_EXCL:与IPC_CREAT一起使用,如果共享内存段已存在则调用失败。
      • 0666:设置权限(可读可写)。

    返回值:返回共享内存段的标识符(一个非负整数),如果出错,返回 -1。

2. shmat

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

  • 原型:

    void* shmat(int shmid, const void *shmaddr, int shmflg);
    
    • shmid:由shmget返回的共享内存段标识符。
    • shmaddr:期望的映射地址,通常设置为NULL,让操作系统自动选择地址。
    • shmflg:标志位,常用的标志是0(表示默认映射),SHM_RDONLY(只读映射)。

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

3. shmdt

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

  • 原型:

    int shmdt(const void *shmaddr);
    
    • shmaddr:共享内存的指针,通常是由shmat返回的指针。

    返回值:成功返回0,失败返回-1

4. shmctl

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

  • 原型

    int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    
    • shmid:共享内存段的标识符。
    • cmd:控制命令,常用的命令有:
      • IPC_STAT:获取共享内存段的状态。
      • IPC_RMID:删除共享内存段。
      • SHM_INFO:获取共享内存的统计信息。
    • buf:用于存储共享内存信息的结构体,shmid_ds结构体定义了共享内存的状态信息。

    返回值:成功返回0,失败返回-1

5.ftok

key_t ftok(const char *pathname, int proj_id);
  • 参数:

    1. pathname:文件路径名(文件或目录的路径),该文件必须存在且具有一定的权限。路径名用于生成一个唯一的标识符。

    2. 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() 解除共享内存映射,程序正常退出。

在这里插入图片描述

源码网址