<think>我们被要求提供Linux系统下共享内存的使用示例和实现方法。根据引用[2]和引用[3]，共享内存是Linux中进程间通信（IPC）最快的一种方式，因为它将同一块内存映射到不同进程的地址空间，进程可以直接访问内存而无需数据拷贝。我们将展示三种常用的共享内存实现方式：POSIX共享内存、System V共享内存和mmap内存映射。
注意：共享内存本身不提供同步机制，因此在实际使用中需要配合互斥锁、信号量等同步机制来避免竞态条件（引用[1]）。
下面分别给出三种共享内存的实现示例：
一、使用POSIX共享内存（基于内存文件系统）
引用[2]提供了一个简单的示例，我们在此基础上进行扩展，展示两个进程（一个写入，一个读取）如何通过共享内存通信。
示例1：POSIX共享内存（写入进程）
```c
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
int main() {
int shm_fd;
char *ptr;
// 创建或打开共享内存对象
shm_fd = shm_open("/my_shared_memory", O_CREAT | O_RDWR, 0666);
if (shm_fd == -1) {
perror("shm_open");
return 1;
}
// 设置共享内存大小（假设我们需要1024字节）
if (ftruncate(shm_fd, 1024) == -1) {
perror("ftruncate");
return 1;
}
// 映射共享内存
ptr = (char *)mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
if (ptr == MAP_FAILED) {
perror("mmap");
return 1;
}
// 写入数据到共享内存
char *message = "Hello, Shared Memory!";
strcpy(ptr, message);
printf("Write Process: Wrote message: %s\n", message);
// 等待一段时间，让读取进程有足够时间读取（实际中应使用同步机制）
sleep(2);
// 解除映射
if (munmap(ptr, 1024) == -1) {
perror("munmap");
return 1;
}
// 关闭共享内存对象（注意：这里没有删除，读取进程结束后再删除）
close(shm_fd);
// 可选：在不再需要时删除共享内存对象
// shm_unlink("/my_shared_memory");
return 0;
}
```
示例2：POSIX共享内存（读取进程）
```c
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
int main() {
int shm_fd;
char *ptr;
// 打开已存在的共享内存对象
shm_fd = shm_open("/my_shared_memory", O_RDONLY, 0666);
if (shm_fd == -1) {
perror("shm_open");
return 1;
}
// 映射共享内存（只读）
ptr = (char *)mmap(NULL, 1024, PROT_READ, MAP_SHARED, shm_fd, 0);
if (ptr == MAP_FAILED) {
perror("mmap");
return 1;
}
// 从共享内存读取数据
printf("Read Process: Read message: %s\n", ptr);
// 解除映射
if (munmap(ptr, 1024) == -1) {
perror("munmap");
return 1;
}
// 关闭共享内存对象
close(shm_fd);
// 删除共享内存对象（由最后一个进程负责删除）
if (shm_unlink("/my_shared_memory") == -1) {
perror("shm_unlink");
return 1;
}
return 0;
}
```
注意：编译时需要链接rt库，使用命令：`gcc -o posix_writer posix_writer.c -lrt` 和 `gcc -o posix_reader posix_reader.c -lrt`
二、使用System V共享内存
示例3：System V共享内存（写入进程）
```c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
int main() {
key_t key = ftok("shmfile", 65); // 生成唯一key
int shm_id;
char *str;
// 创建共享内存段，大小为1024字节
shm_id = shmget(key, 1024, IPC_CREAT | 0666);
if (shm_id == -1) {
perror("shmget");
return 1;
}
// 附加到共享内存
str = (char*)shmat(shm_id, NULL, 0);
if (str == (void*)-1) {
perror("shmat");
return 1;
}
// 写入数据
strcpy(str, "Hello, System V Shared Memory!");
printf("Write Process: Wrote message: %s\n", str);
// 分离共享内存（数据不会立即删除）
if (shmdt(str) == -1) {
perror("shmdt");
return 1;
}
// 注意：这里没有删除共享内存，由读取进程或单独命令删除
return 0;
}
```
示例4：System V共享内存（读取进程）
```c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int main() {
key_t key = ftok("shmfile", 65); // 同样的key
int shm_id;
char *str;
// 获取共享内存
shm_id = shmget(key, 1024, 0666);
if (shm_id == -1) {
perror("shmget");
return 1;
}
// 附加到共享内存
str = (char*)shmat(shm_id, NULL, 0);
if (str == (void*)-1) {
perror("shmat");
return 1;
}
printf("Read Process: Read message: %s\n", str);
// 分离共享内存
if (shmdt(str) == -1) {
perror("shmdt");
return 1;
}
// 删除共享内存
if (shmctl(shm_id, IPC_RMID, NULL) == -1) {
perror("shmctl");
return 1;
}
return 0;
}
```
三、使用mmap内存映射（文件映射）
示例5：mmap内存映射（写入进程）
```c
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
int main() {
int fd;
char *ptr;
// 打开一个文件用于映射
fd = open("shared_file", O_RDWR | O_CREAT, 0666);
if (fd == -1) {
perror("open");
return 1;
}
// 设置文件大小
ftruncate(fd, 1024);
// 映射到内存
ptr = (char *)mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (ptr == MAP_FAILED) {
perror("mmap");
return 1;
}
// 写入数据
strcpy(ptr, "Hello, mmap with file!");
printf("Write Process: Wrote message: %s\n", ptr);
// 解除映射
if (munmap(ptr, 1024) == -1) {
perror("munmap");
return 1;
}
close(fd);
return 0;
}
```
示例6：mmap内存映射（读取进程）
```c
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
int main() {
int fd;
char *ptr;
fd = open("shared_file", O_RDONLY);
if (fd == -1) {
perror("open");
return 1;
}
ptr = (char *)mmap(NULL, 1024, PROT_READ, MAP_SHARED, fd, 0);
if (ptr == MAP_FAILED) {
perror("mmap");
return 1;
}
printf("Read Process: Read message: %s\n", ptr);
if (munmap(ptr, 1024) == -1) {
perror("munmap");
return 1;
}
close(fd);
return 0;
}
```
重要提示：
1. 上述示例中，为了简化没有使用同步机制（如信号量）。在实际应用中，多个进程同时访问共享内存时，必须使用同步机制来避免数据竞争。
2. 共享内存的生命周期管理：POSIX共享内存使用shm_unlink删除，System V共享内存使用shmctl(IPC_RMID)删除，而文件映射则依赖于文件本身（即使进程结束，文件仍然存在）。
3. 共享内存的权限设置：创建时通过权限标志（如0666）设置。
根据引用[4]，共享内存的物理页由内核通过radix树管理，因此高效且可扩展。
最后，根据要求，生成相关问题。
§§相关问题§§
1. 在Linux中，如何确保共享内存访问的同步？
2. 共享内存和消息队列在进程间通信中的性能差异有多大？
3. 如何监控Linux系统中共享内存的使用情况？
4. 共享内存的最大大小是多少？如何调整？</think>### Linux共享内存使用示例与实现方法
共享内存是Linux中最快的进程间通信(IPC)机制，允许多个进程直接访问同一块物理内存区域。以下是三种常用实现方式及其完整示例：
---
#### 一、POSIX共享内存（推荐方式）
基于内存文件系统`shm_open()`实现，符合POSIX标准：
```c
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
// 写入进程
int main() {
int shm_fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0666);
ftruncate(shm_fd, 1024); // 设置共享内存大小
char *ptr = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
strcpy(ptr, "Hello from Process A!"); // 写入数据
sleep(3); // 等待读取进程
shm_unlink("/my_shm"); // 清理资源
munmap(ptr, 1024);
}
// 读取进程
int main() {
int shm_fd = shm_open("/my_shm", O_RDWR, 0666);
char *ptr = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
printf("Received: %s\n", ptr); // 读取数据
munmap(ptr, 1024);
}
```
**编译**：`gcc -o shm_example shm_example.c -lrt`
**特点**：使用文件路径标识内存区域，支持权限控制[^2]
---
#### 二、System V共享内存
传统UNIX IPC机制，通过`shmget()`系统调用：
```c
#include <sys/ipc.h>
#include <sys/shm.h>
// 写入进程
int main() {
key_t key = ftok("shmfile", 65);
int shm_id = shmget(key, 1024, IPC_CREAT | 0666);
char *str = (char*)shmat(shm_id, NULL, 0);
strcpy(str, "System V Shared Memory");
shmdt(str); // 分离但不删除
}
// 读取进程
int main() {
key_t key = ftok("shmfile", 65);
int shm_id = shmget(key, 1024, 0666);
char *str = (char*)shmat(shm_id, NULL, 0);
printf("Read: %s\n", str);
shmdt(str);
shmctl(shm_id, IPC_RMID, NULL); // 删除共享内存
}
```
**特点**：通过key标识内存段，需手动删除[^3]
---
#### 三、mmap文件映射
将普通文件映射到内存空间：
```c
#include <sys/mman.h>
// 写入进程
int main() {
int fd = open("data.bin", O_RDWR | O_CREAT, 0666);
ftruncate(fd, 4096); // 扩展文件大小
int *ptr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
*ptr = 0xDEADBEEF; // 写入数据
msync(ptr, 4096, MS_SYNC); // 确保写入磁盘
munmap(ptr, 4096);
}
// 读取进程
int main() {
int fd = open("data.bin", O_RDONLY);
int *ptr = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0);
printf("Value: 0x%X\n", *ptr);
munmap(ptr, 4096);
}
```
**特点**：数据可持久化到磁盘，适用于大数据传输[^3]
---
### ⚠️ 关键注意事项
1. **同步机制**（必须实现）
```c
// 使用信号量同步
sem_t *sem = sem_open("/sync_sem", O_CREAT, 0666, 1);
sem_wait(sem); // 进入临界区
/* 访问共享内存 */
sem_post(sem); // 离开临界区
```
2. **内核实现原理**
- 共享内存通过`struct shmid_kernel`管理
- 物理页由`struct address_space`的radix树维护
- 虚拟地址通过页表映射到相同物理页[^4]
3. **性能优化**
- 使用`SHM_HUGETLB`分配大页内存（2MB/1GB页）
- 对齐内存访问边界（避免cache抖动）
- 批处理读写操作减少上下文切换
---
### 三种方式对比
| 特性 | POSIX共享内存 | System V共享内存 | mmap文件映射 |
|---------------------|---------------------|---------------------|-------------------|
| 标识方式 | 路径名 | Key | 文件描述符 |
| 生命周期管理 | shm_unlink() | shmctl(IPC_RMID) | 文件系统持久化 |
| 最大尺寸 | /dev/shm分区大小 | 内核shmmax参数 | 文件系统限制 |
| 推荐场景 | 新建项目 | 兼容旧系统 | 大数据持久化 |
> **最佳实践**：POSIX共享内存是现代应用的首选，提供更清晰的API和基于文件系统的管理方式[^2][^3]。
---
扫一扫
1537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
