C++
Linux System V 共享内存原理与实操指南
Linux System V 共享内存是进程间通信效率最高的方式之一，通过直接共享物理内存避免数据拷贝开销。核心涉及 ftok 生成标识、shmget 创建或获取内存、shmat 挂载映射、shmdt 脱离以及 shmctl 控制删除。使用时需注意手动管理同步机制防止数据混乱，并显式删除资源避免内存泄漏。适用于高性能数据传输及底层开发场景，现代开发也可关注 POSIX 共享内存替代方案。
Linux System V 共享内存是进程间通信效率最高的方式之一，通过直接共享物理内存避免数据拷贝开销。核心涉及 ftok 生成标识、shmget 创建或获取内存、shmat 挂载映射、shmdt 脱离以及 shmctl 控制删除。使用时需注意手动管理同步机制防止数据混乱，并显式删除资源避免内存泄漏。适用于高性能数据传输及底层开发场景，现代开发也可关注 POSIX 共享内存替代方案。
在 Linux 进程间通信（IPC）中，共享内存是效率最高的方式之一——它直接让多个进程共享同一块物理内存区域，无需像管道、消息队列那样进行数据拷贝，省去了内核与用户空间之间的频繁数据交换开销。而 System V 共享内存（简称 SysV 共享内存），作为 Linux 早期就支持的经典 IPC 机制，至今仍在很多底层开发、高性能程序中广泛应用。
本文从是什么、怎么工作、怎么用、踩过哪些坑四个维度，彻底搞懂 System V 共享内存，全程附代码示例。
System V 共享内存，是 System V 系列 IPC 机制（包括共享内存、消息队列、信号量）中的一种，核心作用是'让多个进程访问同一块物理内存'，实现高效的数据共享。
我们可以用一个通俗的比喻理解：把物理内存想象成一个'公共仓库'，System V 共享内存就相当于在这个仓库里划分出一块专属区域，然后给多个进程发放'访问权限'，这些进程可以直接往这块区域读写数据，不用再通过'中间人'（比如内核缓冲区）传递，速度自然更快。
问题：
总结：创建和'删除'shm 需要系统调用，使用 shm 不需要（类似 malloc()）。
我们创建管道的时候用了系统调用，使用管道的时候也用了，这也是和共享内存的差别。用户空间最有代表的就是用户可以直接访问。
内核通过 struct shmid_ds 管理共享内存的属性，是共享内存描述结构体的子集，结合 Linux 2.6.18 内核源码，核心字段如下：
struct shmid_ds {
struct ipc_perm shm_perm; // 权限控制结构体（包含 key、uid、gid、mode 等）
size_t shm_segsz; // 共享内存大小（字节）
pid_t shm_cpid; // 创建进程 PID
pid_t shm_lpid; // 最后一次操作该内存的进程 PID
unsigned short shm_nattch;// 当前挂载到该内存的进程数
time_t shm_atime; // 最后一次挂载时间（shmat 调用时间）
time_t shm_dtime; // 最后一次脱离时间（shmdt 调用时间）
time_t shm_ctime; // 最后一次属性修改时间
void *shm_unused2; // 预留字段（内核内部使用）
};
struct ipc_perm是 System V IPC（共享内存、消息队列、信号量）的通用权限结构体，内核通过该结构体的key字段唯一标识一个 IPC 资源。
System V 共享内存的使用流程遵循 '生成 Key→创建 / 获取共享内存→挂载→读写→脱离→删除'，核心 API 包括 ftok、shmget、shmat、shmdt、shmctl，逐一解析如下：
用于将'文件路径 + 项目 ID'转换为唯一的 key_t 类型值，作为共享内存的全局标识 —— 多个进程通过相同的 key 可获取同一块共享内存。
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);
pathname：必须是系统中已存在的文件路径（如"/home"），且调用进程对该文件有访问权限proj_id：非 0 的 8 位整数（如 0x6666），不同的 proj_id 会生成不同的 key（即使路径相同）；key，失败返回 -1（errno 会标识错误原因，如文件不存在、权限不足）。用于创建新的共享内存或获取已存在的共享内存，返回共享内存标识符（shmid），后续操作均通过 shmid 关联共享内存。
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
参数深度解析：
key：ftok 生成的唯一 Key；size：共享内存大小（建议为 4096 的整数倍），创建时需指定，获取时可设为 0；shmflg：权限标志组合，核心组合：
IPC_CREAT：若共享内存不存在则创建，存在则直接获取（常用）IPC_CREAT | IPC_EXCL：若共享内存已存在则报错（确保创建全新内存，避免覆盖）；返回值：成功返回 shmid（非负整数），失败返回 -1。
Key 值补充：
创建成功了就会返回一个共享内存的标识符，也可以叫句柄，但是跟文件描述符可没有关系联系。共享内存一定要有一个标识 shm 唯一性的标识符！在哪里？在它的结构体里一定有一个唯一标识符的。需要用户设置唯一值，作为 shm 在内核中的唯一值，我们叫做 key。
将共享内存映射到当前进程的虚拟地址空间，返回映射后的虚拟地址指针 —— 进程通过该指针读写共享内存。
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数细节：
shmid：shmget 返回的共享内存标识符；shmaddr：指定挂载的虚拟地址（NULL 表示由内核自动分配，推荐使用）；shmflg：挂载标志：
0：可读可写挂载；SHM_RDONLY：只读挂载（进程无写权限）；SHM_RND：若 shmaddr 非 NULL，将挂载地址向下调整为 SHMLBA（内存页边界）的整数倍；返回值：成功返回虚拟地址指针，失败返回 (void*)-1。
将共享内存从当前进程的虚拟地址空间中脱离（解除映射关系），并非删除共享内存。
#include <sys/shm.h>
int shmdt(const void *shmaddr);
shmaddr：shmat 返回的虚拟地址指针；shmdt 就退出，内核会自动解除映射（避免内存泄漏）；用于获取共享内存属性、修改属性或删除共享内存，是共享内存生命周期管理的核心 API。
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数深度解析：
shmid：共享内存标识符；cmd：控制命令（核心 3 种）：
shmid_ds 结构体（如查询挂载进程数、大小）CAP_SYS_ADMIN 权限），属性值从 buf 读取buf：存储属性的结构体指针（IPC_RMID 时可设为 NULL）；返回值：成功返回 0，失败返回 -1。
提供 Shm.hpp 封装类对上述核心 API 进行完整封装，无需修改即可使用。结合 Writer.cc（写进程）和 Reader.cc（读进程），实现跨进程数据读写。
Shm.hpp 封装了'生成 Key→创建 / 获取→挂载→删除→属性查询'的全流程，核心接口与 API 映射关系如下：
| 函数名 | 调用示例 | 功能描述 |
|---|---|---|
| Create() | `shmget(key, size, IPC_CREAT | IPC_EXCL |
| Get() | shmget(key, size, IPC_CREAT) | 获取已存在的共享内存 |
| Attch() | shmat(shmid, NULL, 0) | 挂载共享内存，返回虚拟地址指针 |
| Delete() | shmctl(shmid, IPC_RMID, NULL) | 删除共享内存 |
| GetShmAttr() | shmctl(shmid, IPC_STAT, &ds) | 获取共享内存属性（PID、大小、Key） |
| Debug() | 打印 shmid、size、key（调试用） |
#ifndef __SHM_HPP__
#define __SHM_HPP__
#include <iostream>
#include <cstdio>
#include <sys/shm.h>
#include <string.h>
#include <unistd.h>
const std::string proj_name = "/home";
const int proj_id = 0x6666;
const int g_size = 4096;
static std::string ToHex(long long data) {
char buf[16];
snprintf(buf, sizeof(buf), "0x%llx", data);
return buf;
}
class Shm {
public:
Shm(int size = g_size): _shmid(-1), _size(size), _key(0) {}
~Shm() {}
private:
key_t GetKey() {
_key = ftok(proj_name.c_str(), proj_id);
if(_key < 0) {
perror("ftok");
}
return _key;
}
bool CreateCoreHelper(int flags) {
// 1. 获取 key 值
key_t key = GetKey();
// 2. 创建共享内存
_shmid = shmget(key, _size, flags);
if(_shmid < 0) {
perror("shmget");
return false;
}
return true;
}
public:
// 1.创建共享内存
bool Create() {
return CreateCoreHelper(IPC_CREAT | IPC_EXCL | 0666);
}
// 2.获取共享内存
bool Get() {
return CreateCoreHelper(IPC_CREAT);
}
// 3. 删除共享内存
bool Delete() {
int n = shmctl(_shmid, IPC_RMID, nullptr);
return n < 0 ? false : true;
}
// 4. 获取共享内存属性
void GetShmAttr() {
struct shmid_ds ds;
int n = shmctl(_shmid, IPC_STAT, &ds);
if(n < 0) {
perror("shmctl");
return ;
}
std::cout << ds.shm_cpid << std::endl;
std::cout << ds.shm_segsz << std::endl;
std::cout << ToHex(_key) << std::endl;
}
// 5. 共享内存映射挂载
void *Attch() {
_start = (char *)shmat(_shmid, nullptr, 0);
return _start;
}
// 6. 共享内存去关联
void Detach() {
int n = shmdt(_start);
(void)n;
}
void Debug() {
std::cout << "shmid: " << _shmid << std::endl;
std::cout << "size: " << _size << std::endl;
std::cout << "key: " << ToHex(_key) << std::endl;
}
private:
int _shmid;
int _size;
key_t _key;
char *_start;
};
typedef struct data {
int count;
char buf[26 * 2];
}buffer_t;
#endif
// header only
#include "Shm.hpp"
#include <iostream>
#include <string>
int main() {
Shm shm;
shm.Get();
shm.Debug();
return 0;
}
// header only
#include "Shm.hpp"
#include <iostream>
#include <string>
#include <unistd.h> // Writer -> shm -> Reader
int main() {
// 1.在内核中创建共享内存
Shm shm;
shm.Create();
sleep(3);
shm.Attach();
shm.Debug();
shm.GetShmAttr();
sleep(5);
shm.Delete();
return 0;
}
all:Writer Reader
Reader:Reader.cc
g++ -o $@ $^ -std=c++11
Writer:Writer.cc
g++ -o $@ $^ -std=c++11
.PHONY:clean
clean: rm -f Writer Reader
./Reader./Writter先补充一下之前共享内存代码这块：我们把之前的代码中的大小变成 4097 进行测试，之前我们说过大小必须是 4096 的整数倍，那会发生什么呢。
操作系统会给你申请 4096*2，这不就是浪费了 4095 嘛。
那这样难道就不可以嘛。当然不行，如果你实际是 4097，操作系统给你了 4096*2，那我们访问越界的时候，可能都不会有提示了。至于为什么会这样给，我们后面线程的时候来说
根据附录的内核源码解析，内核通过 struct ipc_ids 和 struct shmid_kernel 管理所有共享内存资源，核心逻辑如下：
shm_ids 全局变量（struct ipc_ids 类型），记录系统中所有共享内存的元数据（如 max_id、in_use、entries 数组）；struct ipc_id_ary 的 entries 数组存储 struct kern_ipc_perm 指针，内核通过 shmid 索引到对应的共享内存权限结构体；struct shmid_kernel 包含 struct file *shm_file 字段，通过文件系统的 inode 和 vm_area_struct 实现物理内存与进程虚拟地址的映射。简单来说：内核将共享内存抽象为一种特殊的 IPC 资源，通过'Key→shmid→内核数据结构→物理内存'的链路，实现对共享内存的创建、挂载、脱离、删除等操作的统一管理。
System V 共享内存虽然高效，但使用时容易踩坑，尤其是新手，以下几个问题必须重点关注：
坑点：共享内存的生命周期独立于进程，若进程异常退出（比如崩溃），没有执行 shmctl(IPC_RMID)，共享内存会一直占用物理内存，长期下来会导致内存泄漏。
解决方法：
ipcs -mipcrm -m 123456（123456 是 shmid）坑点：System V 共享内存没有自带同步机制，若多个进程同时写入，会出现数据覆盖、错乱的问题。
解决方法：搭配 System V 信号量（或互斥锁）使用，实现'互斥访问'——同一时间只有一个进程能读写共享内存。
坑点：不同进程使用 ftok() 生成 key 时，路径（KEY_PATH）或标识（KEY_ID）不一致，会导致生成的 key 不同，无法找到同一个共享内存。
解决方法：所有需要通信的进程，使用完全相同的 KEY_PATH 和 KEY_ID 生成 key；或直接使用固定的 key 值（如 0x123456），避免 ftok() 的潜在问题。
坑点：设置的共享内存大小不足，导致写入数据被截断；或设置过大，浪费物理内存。
System V 共享内存的核心优势是'高效'，核心劣势是'需要手动管理同步和生命周期'，因此它适合以下场景：
最后提醒：虽然 System V 共享内存很经典，但在现代 Linux 开发中，也可以关注 POSIX 共享内存（如 shm_open()、mmap()），它更灵活、更符合 POSIX 标准，不过 System V 共享内存的兼容性和底层可控性，依然是它不可替代的优势。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online