深入理解共享内存：原理、优势与应用（C++实现详解）
在多进程或多线程编程中，进程间通信（Inter-Process Communication, IPC） 是实现数据交换与协作的关键技术。共享内存（Shared Memory）作为一种高效的IPC机制，因其卓越的性能和低延迟性，广泛应用于各种需要快速数据交换的场景中。本文将从理论和底层原理出发，全面解析共享内存的工作机制、优势、应用场景以及在实际开发中需要注意的问题。
目录
- 共享内存概述
- 共享内存的工作原理
- 深入解析共享内存管理类：C++实现详解
- 代码结构概览
共享内存概述
共享内存是一种允许多个进程直接访问同一块物理内存区域的通信机制。通过共享内存，进程无需通过内核频繁拷贝数据，可以实现高效的数据交换。这种机制在需要频繁、大量数据传输的应用中，如实时数据处理、图像处理、数据库缓存等，表现尤为出色。
共享内存的基本概念
- 物理内存映射：共享内存区域映射到多个进程的虚拟地址空间中，使得这些进程可以直接读写这块内存。
- 内存标识符：每块共享内存都有一个唯一的标识符，用于进程间的引用和管理。
- 生命周期管理：共享内存的创建、连接、分离和销毁需要明确的管理，以避免内存泄漏和资源冲突。
因此也就是说这些工作都是OS一个人做的，是不是就代表着这些共享内存可以存在很多份呢？既然有不同份数，不同的地址，就注定了操作系统要对其进行管理！
也就是共享内存也有它自己的结构体，有他自己的task_struct和数据，因此OS就一定会有相关的接口供我们使用
共享内存的工作原理
共享内存的实现通常依赖于操作系统提供的系统调用。在Linux系统中，常见的共享内存实现是System V共享内存
System V共享内存
System V共享内存通过以下步骤实现：
1. 创建或获取共享内存：使用shmget系统调用，根据键值创建或获取一个共享内存段。
2. 附加共享内存：使用shmat将共享内存段映射到进程的地址空间。
3. 访问共享内存：进程可以通过指针直接访问共享内存区域，实现数据的读写。
4. 分离共享内存：使用shmdt将共享内存段从进程的地址空间中分离。
5. 删除共享内存：使用shmctl删除共享内存段，释放资源。
那么具体是如何调用的呢？
1. 创建或获取共享内存：使用 shmget 系统调用
shmget 函数用于创建新的共享内存段或访问一个已经存在的共享内存段。它的主要参数包括键值、内存大小和权限标志。
函数原型：
int shmget(key_t key, size_t size, int shmflg);
- key：一个系统唯一的键值，通常通过
ftok()函数生成，用于标识共享内存段。 - size：需要分配的共享内存的大小（字节数）。如果是访问已存在的内存段，则此值可以为0。
- shmflg：操作标志，通常包括权限位和状态标志，如
IPC_CREAT（如果不存在则创建）、IPC_EXCL（与IPC_CREAT同用，确保创建新的段）等。
使用示例：
key_t key = ftok("pathname", id);
int shmid = shmget(key, 1024, 0666|IPC_CREAT);
if (shmid == -1) {
perror("shmget failed");
exit(1);
}
2. 附加共享内存：使用 shmat 系统调用
shmat 函数将共享内存段映射到调用进程的地址空间，使得进程可以通过指针直接访问内存。
函数原型：
void *shmat(int shmid, const void *shmaddr, int shmflg);
- shmid：由
shmget返回的共享内存标识符。 - shmaddr：指定共享内存连接到进程地址空间中的特定地址，通常设置为
NULL，由系统选择。 - shmflg：操作标志，通常为
SHM_RND（将shmaddr向下舍入到共享内存段大小的最近倍数）或0。
使用示例：
char* shm_ptr = (char*) shmat(shmid, NULL, 0);
if (shm_ptr == (char *) -1) {
perror("shmat failed");
exit(1);
}
3. 访问共享内存
进程可以通过返回的指针直接对共享内存进行读写操作，就如同对普通内存数组或结构体的操作一样。
示例：
strcpy(shm_ptr, "Hello, shared memory!");
printf("Shared memory contains: %s\n", shm_ptr);
4. 分离共享内存：使用 shmdt 系统调用
shmdt 用于将共享内存段从当前进程的地址空间中分离。尽管分离了内存，但该内存段仍然存在系统中，不会被自动销毁。
函数原型：
int shmdt(const void *shmaddr);
- shmaddr：要分离的共享内存段的地址。
使用示例：
if (shmdt(shm_ptr) == -1) {
perror("shmdt failed");
exit(1);
}
5. 删除共享内存：使用 shmctl 系统调用
shmctl 允许你对共享内存段进行控制操作，包括删除共享内存段。
函数原型：
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
- shmid：共享内存标识符。
- cmd：控制操作，如
IPC_RMID用于删除共享内存段。 - buf：指向共享内存数据结构的指针，对于删除操作，通常设置为
NULL。
使用示例：
if (shmctl(shmid, IPC_RMID, NULL) == -1) {
perror("shmctl IPC_RMID failed");
exit(1);
}
通过以上步骤，你可以在程序中有效地创建、使用和管理共享内存，这对于需要高效 IPC 机制的应用尤为重要。
那么接下来就让我们详细的通过代码来学习共享内存，话不多说，上代码！
深入解析共享内存管理类：C++实现详解
代码结构概览
以下是Shm类的头文件代码：
#ifndef __SHM_HPP__
#define __SHM_HPP__
#include 接下来，我们将逐步解析Shm类的各个部分。
Shm类详解
Shm类主要负责管理共享内存的生命周期，包括创建、连接、分离和销毁。通过封装底层的系统调用，Shm类提供了简洁易用的接口，使得共享内存的操作更加直观和安全。
宏定义与全局常量
在头文件的开头，我们定义了一些全局常量和宏：
const int gCreater = 1;
const int gUser = 2;
const std::string gpathname = "/home/whb/code/111/code/lesson22/4.shm";
const int gproj_id = 0x66;
const int gShmSize = 4097; // 4096*n
gCreater和gUser：用于区分进程在共享内存中的角色。gCreater表示创建者，gUser表示使用者。gpathname：用于生成共享内存键值的路径名。ftok函数需要一个存在的路径名。gproj_id：项目标识符，用于与路径名一起生成唯一的键值。gShmSize：共享内存的大小。这里设置为4097字节，通常是4096的整数倍。
类成员变量
private:
key_t _key;
int _shmid;
std::string _pathname;
int _proj_id;
int _who;
void* _addrshm;
_key：共享内存的键值，由ftok生成，用于标识共享内存区域。_shmid：共享内存标识符，由shmget返回，用于后续操作。_pathname和_proj_id：用于生成共享内存键值的路径名和项目标识符。_who：角色标识，区分创建者和使用者。_addrshm：共享内存的地址指针，通过shmat映射到进程的地址空间。
构造函数与析构函数
构造函数
public:
Shm(const std::string &pathname, int proj_id, int who)
: _pathname(pathname), _proj_id(proj_id), _who(who), _addrshm(nullptr)
{
_key = GetCommKey();
if (_who == gCreater)
GetShmUseCreate();
else if (_who == gUser)
GetShmForUse();
_addrshm = AttachShm();
std::cout << "shmid: " << _shmid << std::endl;
std::cout << "_key: " << ToHex(_key) << std::endl;
}
- 参数说明：
pathname：用于生成键值的路径名。proj_id：项目标识符，用于生成键值。who：角色标识，gCreater表示创建者，gUser表示使用者。
- 初始化流程：
- 初始化成员变量。
- 调用
GetCommKey()生成共享内存键值。 - 根据角色调用
GetShmUseCreate()或GetShmForUse()获取共享内存标识符。 - 调用
AttachShm()将共享内存映射到进程的地址空间。 - 输出共享内存标识符和键值，便于调试。
析构函数
~Shm()
{
if (_who == gCreater)
{
int res = shmctl(_shmid, IPC_RMID, nullptr);
}
std::cout << "shm remove done..." << std::endl;
}
- 功能：
- 如果角色是创建者，在析构时调用
shmctl删除共享内存，释放资源。 - 输出删除完成的提示信息，便于确认资源已释放。
- 如果角色是创建者，在析构时调用
私有成员函数
GetCommKey()
key_t GetCommKey()
{
key_t k = ftok(_pathname.c_str(), _proj_id);
if (k < 0)
{
perror("ftok");
}
return k;
}
- 功能：使用
ftok根据路径名和项目ID生成共享内存键值。 - 注意事项：
ftok需要路径存在且有读取权限，否则会失败。- 键值的唯一性依赖于路径名和项目ID的组合。
GetShmHelper(key_t key, int size, int flag)
int GetShmHelper(key_t key, int size, int flag)
{
int shmid = shmget(key, size, flag);
if (shmid < 0)
{
perror("shmget");
}
return shmid;
}
- 功能：封装
shmget函数，获取共享内存标识符。 - 参数说明：
key：共享内存键值。size：共享内存大小。flag：权限标志，如IPC_CREAT、IPC_EXCL等。
- 错误处理：如果
shmget失败，输出错误信息。
RoleToString(int who)
std::string RoleToString(int who)
{
if (who == gCreater)
return "Creater";
else if (who == gUser)
return "gUser";
else
return "None";
}
- 功能：将角色标识转换为字符串，便于调试和日志输出。
AttachShm()
void* AttachShm()
{
if (_addrshm != nullptr)
DetachShm(_addrshm);
void* shmaddr = shmat(_shmid, nullptr, 0);
if (shmaddr == nullptr)
{
perror("shmat");
}
std::cout << "who: " << RoleToString(_who) << " attach shm..." << std::endl;
return shmaddr;
}
- 功能：将共享内存附加到进程的地址空间。
- 流程：
- 如果已经有映射，先调用
DetachShm进行分离。 - 调用
shmat附加共享内存。 - 输出附加信息，便于确认共享内存已成功映射。
- 如果已经有映射，先调用
- 错误处理：如果
shmat失败，输出错误信息。
DetachShm(void* shmaddr)
void DetachShm(void* shmaddr)
{
if (shmaddr == nullptr)
return;
shmdt(shmaddr);
std::cout << "who: " << RoleToString(_who) << " detach shm..." << std::endl;
}
- 功能：将共享内存从进程的地址空间分离。
- 流程：
- 检查共享内存地址是否为空。
- 调用
shmdt分离共享内存。 - 输出分离信息，便于确认共享内存已成功分离。
ToHex(key_t key)
std::string ToHex(key_t key)
{
char buffer[128];
snprintf(buffer, sizeof(buffer), "0x%x", key);
return buffer;
}
- 功能：将键值转换为十六进制字符串，便于显示和调试。
- 应用场景：在日志或调试信息中展示键值。
GetShmUseCreate()
bool GetShmUseCreate()
{
if (_who == gCreater)
{
_shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL | 0666);
if (_shmid >= 0)
return true;
std::cout << "shm create done..." << std::endl;
}
return false;
}
- 功能：创建一个新的共享内存区域。
- 流程：
- 检查角色是否为创建者。
- 调用
GetShmHelper尝试创建共享内存，使用IPC_CREAT | IPC_EXCL标志确保共享内存不存在时才创建，避免重复创建。 - 如果创建成功，返回
true，否则输出创建完成信息。
GetShmForUse()
bool GetShmForUse()
{
if (_who == gUser)
{
_shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | 0666);
if (_shmid >= 0)
return true;
std::cout << "shm get done..." << std::endl;
}
return false;
}
- 功能：连接到已存在的共享内存区域。
- 流程：
- 检查角色是否为使用者。
- 调用
GetShmHelper获取共享内存标识符，使用IPC_CREAT标志在共享内存不存在时创建，并设置权限为可读写（0666）。 - 如果获取成功，返回
true，否则输出获取完成信息。
公有成员函数
Zero()
void Zero()
{
if(_addrshm)
{
memset(_addrshm, 0, gShmSize);
}
}
- 功能：将共享内存区域的内容全部清零。
- 应用场景：在初始化共享内存时，确保内存内容为空。
Addr()
void* Addr()
{
return _addrshm;
}
- 功能：返回共享内存的地址指针，供用户访问和操作。
- 应用场景：在进程中直接读写共享内存数据。
DebugShm()
void DebugShm()
{
struct shmid_ds ds;
int n = shmctl(_shmid, IPC_STAT, &ds);
if(n < 0) return;
std::cout << "ds.shm_perm.__key : " << ToHex(ds.shm_perm.__key) << std::endl;
std::cout << "ds.shm_nattch: " << ds.shm_nattch << std::endl;
}
- 功能：输出共享内存的调试信息，包括键值和连接数量。
- 应用场景：在开发和调试过程中，检查共享内存的状态和连接数。
提高共享内存的安全性：结合管道使用
虽然共享内存（Shared Memory）在进程间通信（IPC）中具有高效、低延迟的优势，但其本身也存在一些安全性和同步性的问题。由于多个进程可以同时访问共享内存区域，如果缺乏适当的同步机制，可能会导致数据竞争、数据不一致甚至安全漏洞。为了在保证高性能的同时提升共享内存的安全性，我们可以将共享内存与管道（FIFO）结合使用。
为什么仅使用共享内存不够安全？
共享内存允许多个进程直接访问同一块物理内存区域，这带来了以下潜在问题：
- 数据竞争（Race Conditions）：多个进程同时读写共享内存，可能导致数据不一致或损坏。
- 同步困难：共享内存本身不提供任何同步机制，开发者需要额外实现互斥锁、信号量等同步手段。
- 安全性风险：未经授权的进程可能访问或篡改共享内存中的敏感数据。
结合管道提升安全性
为了解决上述问题，我们可以将共享内存与命名管道（Named Pipe）结合使用。具体来说：
- 共享内存：用于高效地传输大量数据。
- 命名管道：用于进程间的通知和同步，确保数据在共享内存中的读写操作有序进行，防止数据竞争。
通过这种组合，管道负责控制数据的读写时机，而共享内存则负责实际的数据传输。这不仅提高了数据传输的效率，还增强了通信过程的安全性和可靠性。
示例代码解析
以下是一个结合共享内存和命名管道的示例，包括服务器端（server.cc）和客户端（client.cc）的实现。该示例展示了如何通过管道进行通知，从而安全地在共享内存中交换数据。
server.cc
// server.cc
#include "shm.hpp"
#include "namedPipe.hpp"
#include 代码解析：
-
管道初始化：
- 接收管道：
client_to_server_fifo用于接收来自客户端的通知。 - 发送管道：
server_to_client_fifo用于向客户端发送处理完成的通知。
- 接收管道：
-
共享内存初始化：
- 使用
Shm类创建或获取共享内存段，并将其附加到服务器进程的地址空间。
- 使用
-
主循环：
- 服务器通过
pipe_recv.ReadNamedPipe等待客户端的通知。 - 一旦收到通知，服务器从共享内存中读取数据，进行处理（如转换为大写）。
- 处理后的数据再次写入共享内存，并通过
pipe_send.WriteNamedPipe通知客户端处理完成。
- 服务器通过
client.cc
// client.cc
#include "shm.hpp"
#include "namedPipe.hpp"
#include 代码解析：
-
管道初始化：
- 发送管道：
client_to_server_fifo用于向服务器发送通知。 - 接收管道：
server_to_client_fifo用于接收服务器的响应通知。
- 发送管道：
-
共享内存初始化：
- 使用
Shm类连接到已存在的共享内存段，并将其附加到客户端进程的地址空间。
- 使用
-
主循环：
- 客户端获取用户输入，将输入数据写入共享内存。
- 通过
pipe_send.WriteNamedPipe发送通知给服务器，表示数据已准备好。 - 客户端通过
pipe_recv.ReadNamedPipe等待服务器的响应通知。 - 一旦收到响应，客户端从共享内存中读取处理后的数据并显示。
工作流程概述
-
初始化阶段：
- 服务器和客户端分别创建并打开各自的命名管道和共享内存。
- 服务器作为共享内存的创建者，负责删除共享内存的生命周期。
-
数据交换阶段：
- 客户端获取用户输入，并将数据写入共享内存。
- 客户端通过管道发送通知给服务器，告知有新数据可供处理。
- 服务器接收到通知后，从共享内存中读取数据，进行处理（例如转换为大写）。
- 服务器将处理后的数据写回共享内存，并通过管道通知客户端处理完成。
- 客户端接收到服务器的通知后，从共享内存中读取处理后的数据并显示。
-
终止阶段：
- 当客户端或服务器决定退出时，适当分离和关闭共享内存及管道。
优势分析
通过将共享内存与管道结合使用，我们能够充分发挥两者的优势，同时克服各自的局限性：
-
共享内存：
- 高效的数据传输，适用于大数据量的交换。
- 低延迟，减少了数据拷贝的开销。
-
命名管道：
- 提供同步机制，确保数据读写的有序性。
- 作为通知机制，减少了轮询的需求，提高了系统资源的利用率。
- 增强了安全性，避免了未经授权的进程直接访问共享内存。
注意事项
在实际开发中，结合使用共享内存和管道时，需要注意以下几点：
-
同步机制：
- 确保管道通知与共享内存的读写操作严格配合，避免数据竞争。
- 可以进一步结合互斥锁（Mutex）或信号量（Semaphore）等同步工具，增强同步的可靠性。
-
错误处理：
- 充分处理系统调用可能出现的错误，如管道创建失败、共享内存附加失败等，保证程序的健壮性。
-
资源管理：
- 确保在程序终止时正确分离和删除共享内存及关闭管道，防止资源泄漏。
-
权限控制：
- 合理设置共享内存和管道的权限，防止未授权的访问和数据泄露。
通过以上措施，可以构建一个高效、安全、可靠的进程间通信机制，充分利用共享内存的性能优势，同时确保通信过程的安全性和数据的一致性。
扩展阅读
如果您对结合使用共享内存和管道有更多的兴趣，建议进一步研究以下内容：
- 同步原语：深入了解互斥锁、信号量、条件变量等同步工具在多进程环境中的应用。
- 错误恢复机制：设计健壮的错误恢复策略，确保在通信异常时能够安全地恢复或重启进程。
- 安全加固：通过加密、身份验证等手段，进一步提升共享内存通信的安全性。
通过不断学习和实践，您将能够构建更加复杂和高效的系统，充分发挥共享内存和管道在进程间通信中的潜力。
结语
通过结合共享内存与命名管道的方式，我们不仅能够实现高效的数据传输，还能够增强通信过程的安全性和可靠性。希望本文的内容能够帮助您在实际项目中灵活运用这些技术，构建高性能且安全的进程间通信机制。