【Linux】进程间通信：system V共享内存

🔥个人主页：Quitecoder

🔥专栏：linux笔记仓

01.system V共享内存

本地通信方案 system V IPC ：共享内存，消息队列，信号量
System V 共享内存提供了进程间共享内存区域的机制。通过这个机制，多个进程可以访问同一块物理内存，而不需要复制数据

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据

这里，OS为进程开辟内存空间

前面提到过，动态库首先从磁盘加载到物理内存，再通过页表映射到地址空间的共享区，那么这段内存也可以

那么操作系统开辟的内存经过页表映射到进程的地址空间，再共享区中申请一段空间，然后把共享内存的其实虚拟地址返回，交给上层用户，就可以向这一段内存写入

这一段内存也可以映射到另一个进程B的共享区，返回虚拟地址，此时A和B就看到同一份资源

共享内存的核心思想是：

• 同一块物理内存被映射到多个进程的虚拟地址空间中。
• 每个进程通过自己的虚拟地址访问这块物理内存。
• 由于多个进程访问的是同一块物理内存，因此它们可以看到彼此写入的数据

OS提供上面的系统调用，AB,CD,EF–共享内存在系统中可以同时存在多份，供不同个数、不同对进程同时进行通信

OS注定要对共享内存进行管理，共享内存不是简单的一段内存空间，也要有描述并管理共享内存的数据结构和匹配的算法

共享内存= 内存空间（数据）+ 共享内存的属性

02.创建共享内存

代码准备

shmget函数
功能：用来创建共享内存
原型

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

key_t key

• 作用：共享内存段的唯一标识符。
• 生成方式：
  • 可以通过 ftok() 函数生成一个唯一的 key。
  • 也可以直接指定一个整数值（如 1234），但需要确保该值不会与其他共享内存段冲突。
• 特殊值：
  • 如果 key 为 IPC_PRIVATE，则总是创建一个新的共享内存段。

size_t size

• 作用：共享内存段的大小（以字节为单位）。
• 注意事项：
  • 如果 size 小于共享内存段的最小大小（通常是 1 页，即 4096 字节），系统会自动将其调整为最小大小。
  • 如果 size 大于现有共享内存段的大小，系统会扩展共享内存段。

int shmflg

• 作用：标志位，用于控制共享内存段的创建和访问权限。
• 常用标志：
  • IPC_CREAT：如果共享内存段不存在，则创建它。
  • IPC_EXCL：与 IPC_CREAT 一起使用，如果共享内存段已存在，则返回错误，如果返回成功了，意味着这shm是全新的。
  • 权限位：用于设置共享内存段的访问权限（如 0666 表示所有用户可读可写）。

ftok() 用于生成一个唯一的 key_t 类型的键值（key）

#include <sys/ipc.h>

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

1. const char *pathname

• 作用：文件路径名，通常是一个已存在的文件。
• 用途：ftok() 会根据该文件的 inode 号和设备号生成键值。
• 注意事项：
  • 文件必须存在，否则 ftok() 会失败。
  • 文件路径名可以是绝对路径或相对路径。

2. int proj_id

• 作用：项目 ID，通常是一个 8 位的整数（取值范围为 0 到 255）。
• 用途：ftok() 会将 proj_id 的低 8 位与文件的 inode 号和设备号结合，生成键值。
• 注意事项：
  • 不同的 proj_id 可以生成不同的键值，即使使用相同的文件路径名。

返回值

• 成功：返回生成的 key_t 类型的键值。
• 失败：返回 -1，并设置 errno 以指示错误原因。

#pragma once

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

using namespace std;
const string pathname ="/home/dyx/bitcode/sharememory";
const int proj_id = 0x66;

key_t GetCommkey(const string &path,int id)
{
    key_t k =ftok(path.c_str(),id);
    if(k<0)
    {
        perror("ftok");
    }
    return k;
}

头文件定义获取key的函数，固定路径为当前路径，客户端和服务端调用同样的函数，传递同样的参数

这个键值的作用是让两个进程能够 ​访问同一个共享内存段

shmget成功时返回共享内存段的标识符（shmid）

int ShmGet(key_t key,int size)
{
    int shmid=shmget(key,size,IPC_CREAT | IPC_EXCL);
    if(shmid<0)
    {
        perror("shmget");
    }
    return shmid;
}

IPC_EXCL，已经有再创建就报错

共享内存的生命周期
• 创建：由第一个调用 shmget 的进程创建。
• 使用：多个进程可以同时附加到共享内存段，访问其中的数据。
• 销毁：当所有进程都分离共享内存段（shmdt）并且没有进程引用时，共享内存段会被销毁。

共享内存不随着进程的退出而释放，所有权属于操作系统，所以需要我们手动释放，生命周期随内核

IPC指令

这里删除只能用shmid来删除

key属于用户形成，内核使用的一个字段，用户不能使用key来进行shm的管理，key主要是内核区分共享内存的唯一性的（类似于文件的struct file*）

shmid是内核返回给用户的一个标识符，用来进行用户级对共享内存进行管理的id值（类似于fd）

除了上面的删除方法，还可以使用系统调用

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

• shmid:由shmget返回的共享内存标识码
• cmd:将要采取的动作（有三个可取值）
• buf:指向一个保存着共享内存的模式状态和访问权限的数据结构

代码封装

#pragma once

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

#define Creater 1
#define User 2
using namespace std;
const string pathname = "/home/dyx/bitcode/sharememory";
const int proj_id = 0x66;
const int SIZE = 4096;
class Shm
{
private:
    key_t GetCommkey()
    {
        key_t k = ftok(_pathname.c_str(), _proj_id);
        if (k < 0)
        {
            perror("ftok");
        }
        return k;
    }
    int ShmGet(key_t key, int size,int flag)
    {
        int shmid = shmget(key, size, flag);
        if (shmid < 0)
        {
            perror("shmget");
        }
        return shmid;
    }
public:
    Shm(const string &path, int id, int who)
        : _pathname(path), _proj_id(id), _who(who)
    { 
        _key=GetCommkey();
        if(_who==Creater) GetShmForCreate();
        else if(_who == User) GetShmForUse();
    }
    
    int GetShmid()
    {
        return _shmid;
    }
    bool GetShmForCreate()
    {
        if(_who==Creater)
        {
           _shmid = ShmGet(_key,SIZE,IPC_CREAT|IPC_EXCL);
           if(_shmid >=0) return true;
        }
        return false;
    }
    bool GetShmForUse()
    {
        if(_who==User)
        {
           _shmid = ShmGet(_key,SIZE,IPC_CREAT);
           if(_shmid >=0) return true;
        }
        return false;
    }
    ~Shm()
    {
        if(_who==Creater)
        {
            int res = shmctl(_shmid,IPC_RMID,nullptr);
        }
    }
private:
    key_t _key;
    int _shmid;
    string _pathname;
    int _proj_id;
    int _who;
};

(1) GetCommkey
• 功能：生成共享内存段的键值。

• 说明：
• 使用 ftok 函数，根据 _pathname 和 _proj_id 生成键值。
• 如果生成失败，打印错误信息。

(2) ShmGet
• 功能：创建或获取共享内存段。

• 使用 shmget 函数，根据 key、size 和 flag 创建或获取共享内存段。
• 如果失败，打印错误信息。

(3) 构造函数
• 功能：初始化共享内存段。
• 实现：

Shm(const string &path, int id, int who)
    : _pathname(path), _proj_id(id), _who(who)
{ 
    _key = GetCommkey();
    if (_who == Creater) GetShmForCreate();
    else if (_who == User) GetShmForUse();
}

• 说明：
• 初始化成员变量 _pathname、_proj_id 和 _who。
• 调用 GetCommkey 生成键值。
• 根据 _who 的值，调用 GetShmForCreate 或 GetShmForUse 初始化共享内存段。

(4) GetShmForCreate
• 功能：创建共享内存段。
• 实现：

bool GetShmForCreate()
{
    if (_who == Creater)
    {
       _shmid = ShmGet(_key, SIZE, IPC_CREAT | IPC_EXCL);
       if (_shmid >= 0) return true;
    }
    return false;
}

• 说明：
• 如果当前进程是创建者（Creater），则调用 ShmGet 创建共享内存段。
• 使用 IPC_CREAT | IPC_EXCL 标志，确保共享内存段不存在时才创建。

(5) GetShmForUse
• 功能：获取共享内存段。
• 实现： 如果当前进程是使用者（User），则调用 ShmGet 获取共享内存段。

03.挂接共享内存

shmat函数

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

• shmaddr:指定连接的地址
• shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
• 返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1

• shmaddr为NULL，核心自动选择一个地址
• shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
• shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr - (shmaddr % SHMLBA)
• shmflg=SHM_RDONLY，表示连接操作用来只读共享内存

void *AttachShm()
{
    void * shmaddr =shmat(_shmid,nullptr,0);
    if(shmaddr==nullptr)
    {
        perror("shmat");
    }
    return shmaddr;
}

04.通信

我们现在封装完它所有的功能，连接到地址空间后得到add

共享内存不提供对共享内存的任何保护机制，会存在数据不一致问题
我们在访问共享内存的时候，没有任何系统调用，因为今天访问的是堆栈之间的用户空间，可以直接访问

05.构建保护

这里共享内存没有自己的保护机制，但是管道是有的，我们可以创建共享内存的同时创建管道，在一个进程向共享内存中写完后通过管道向另一个进程发送信息，进程开始读数据