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