System V共享内存详解：在Linux上实现内存共享的最佳实践
个人主页：chian-ocean
文章专栏-Linux
System V共享内存详解：在Linux上实现内存共享的最佳实践
- 个人主页：chian-ocean
- 文章专栏-Linux
- 前言：
- `system V`共享内存
- `System V`共享内存的特点：
- `System V`共享内存流程：
- `system V`共享内存函数：
- 1. `shmget`
- 2. `shmat`
- 3. `shmdt`
- 4. `shmctl`
- 5.`ftok`
- `shmid_ds`结构体
- 观察`shmif_ds`结构体
- 代码的工作流程：
- 总结
- 共享内存通信实例（管道控制同步）
- 1. 构建管道类
- 2. 获取`key`值
- 3.创建共享内存段
- 4.映射、使用和销毁共享内存
- **服务端：**
- 客户端：
- 源码网址
前言：
System V的共享内存是Unix操作系统中一种进程间通信（IPC）机制，它允许不同的进程通过共享一块物理内存区域来交换数据。共享内存提供了高效的进程间通信方式，因为进程可以直接读写共享区域，而不需要通过内核或其他进程的中介。
system V共享内存
System V共享内存的特点：
- 高效性：通过共享内存，不同进程可以直接访问和修改数据，而不需要经过数据复制的过程，减少了开销。
- 持久性：共享内存段在进程退出后仍然存在，直到显式地由进程删除。
- 权限控制：共享内存段可以设定访问权限，控制哪些进程可以读写共享内存。
System V共享内存流程：
- 获取
key值：进程通过ftok系统调用来计算出key值. - 创建共享内存段：进程使用
shmget系统调用来创建或访问共享内存段。 - 映射共享内存：通过
shmat系统调用，将共享内存段映射到进程的虚拟地址空间中。 - 使用共享内存：进程可以直接通过指针访问共享内存，就像访问普通内存一样。
- 解除映射：进程使用
shmdt来解除对共享内存段的映射。 - 删除共享内存：当不再需要共享内存时，进程通过
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);
-
参数：
-
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; // 结束程序
}
代码的工作流程：
- 获取共享内存标识符 (
shmid)：通过Getshmid()获取共享内存的标识符。Getshmid()应该是用户自己定义的一个函数，返回有效的共享内存段ID。 - 映射共享内存：通过
shmat函数将共享内存段映射到当前进程的地址空间。这里使用的是nullptr，表示操作系统会自动选择一个合适的地址来映射共享内存。 - 获取共享内存信息：调用
shmctl函数并使用IPC_STAT命令来获取共享内存段的状态，保存在shmid_ds结构体中。这个结构体包含了共享内存的权限、大小、创建进程ID、key值等信息。 - 输出共享内存的信息：输出共享内存的权限、大小、创建进程ID以及
key值。注意，在输出创建共享内存的进程ID时，代码中有个小错误，应改为shmds.shm_cpid，而不是shmds.shm_perm.mode，因为mode字段是权限信息。 - 解除共享内存映射：调用
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()解除共享内存映射，程序正常退出。
源码网址
本文地址：https://www.vps345.com/11671.html
上一篇：Linux下CUDA安装全攻略
