如何在 C 中与 Linux 一起使用共享内存
Posted
技术标签:
【中文标题】如何在 C 中与 Linux 一起使用共享内存【英文标题】：How to use shared memory with Linux in C 【发布时间】：2011-08-05 02:51:51 【问题描述】：我的一个项目有点问题。
我一直在尝试找到一个有据可查的示例，使用 fork() 共享内存，但没有成功。
基本上场景是当用户启动程序时，我需要在共享内存中存储两个值：current_path 是一个 char* 和一个 file_name 也是 char*。
根据命令参数，一个新进程以fork() 启动，该进程需要读取和修改存储在共享内存中的 current_path 变量，而 file_name 变量是只读的。
有没有关于共享内存的很好的教程和示例代码（如果可能），你可以指导我吗？
【问题讨论】：
您可以考虑使用线程而不是进程。然后整个内存被共享，没有更多的技巧。 下面的答案讨论了 System V IPC 机制，shmget() 等。以及带有MAP_ANON（又名MAP_ANONYMOUS）的纯mmap() 方法——尽管MAP_ANON 不是由POSIX 定义的。还有用于管理共享内存对象的 POSIX shm_open() 和 shm_close()。 [...继续...]
[...continuation...] 这些具有与 System V IPC 共享内存相同的优势——共享内存对象可以在创建它的进程的生命周期之后持续存在（直到某个进程执行shm_unlink()），而使用mmap() 的机制需要一个文件和MAP_SHARED 来持久化数据（而MAP_ANON 排除持久性）。在shm_open()规范的基本原理部分有一个完整的例子。
【参考方案1】：
有两种方法：shmget 和 mmap。我将讨论mmap，因为它更现代、更灵活，但如果您更愿意使用旧式工具，可以查看man shmget (or this tutorial)。
mmap() 函数可用于分配具有高度可定制参数的内存缓冲区，以控制访问和权限，并在必要时使用文件系统存储支持它们。
以下函数创建一个进程可以与其子进程共享的内存缓冲区：
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
void* create_shared_memory(size_t size)
// Our memory buffer will be readable and writable:
int protection = PROT_READ | PROT_WRITE;
// The buffer will be shared (meaning other processes can access it), but
// anonymous (meaning third-party processes cannot obtain an address for it),
// so only this process and its children will be able to use it:
int visibility = MAP_SHARED | MAP_ANONYMOUS;
// The remaining parameters to `mmap()` are not important for this use case,
// but the manpage for `mmap` explains their purpose.
return mmap(NULL, size, protection, visibility, -1, 0);
下面是一个使用上面定义的函数来分配缓冲区的示例程序。父进程会写一条消息，fork，然后等待它的子进程修改缓冲区。两个进程都可以读写共享内存。
#include <string.h>
#include <unistd.h>
int main()
char parent_message[] = "hello"; // parent process will write this message
char child_message[] = "goodbye"; // child process will then write this one
void* shmem = create_shared_memory(128);
memcpy(shmem, parent_message, sizeof(parent_message));
int pid = fork();
if (pid == 0)
printf("Child read: %s\n", shmem);
memcpy(shmem, child_message, sizeof(child_message));
printf("Child wrote: %s\n", shmem);
else
printf("Parent read: %s\n", shmem);
sleep(1);
printf("After 1s, parent read: %s\n", shmem);
【讨论】：
这就是为什么 Linux 让没有经验的开发者如此沮丧的原因。手册页没有解释如何实际使用它，也没有示例代码。 :( 哈哈我明白你的意思，但这实际上是因为我们不习惯阅读手册页。当我学会阅读并习惯它们时，它们变得比带有特定演示的糟糕教程更有用。我记得我在操作系统课程中获得了 10/10，考试期间只使用手册页作为参考。shmget 是一种非常过时的，有些人会说不推荐使用的共享内存方式......最好使用mmap 和shm_open，纯文件，或者简单地使用@987654332 @.
@Mark @R 你们是对的，我会在答案中指出这一点以供将来参考。
嗯，这个答案由于某种原因变得流行，所以我决定让它值得一读。只用了4年【参考方案2】：
这是一个共享内存的例子：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SHM_SIZE 1024 /* make it a 1K shared memory segment */
int main(int argc, char *argv[])
key_t key;
int shmid;
char *data;
int mode;
if (argc > 2)
fprintf(stderr, "usage: shmdemo [data_to_write]\n");
exit(1);
/* make the key: */
if ((key = ftok("hello.txt", 'R')) == -1) /*Here the file must exist */
perror("ftok");
exit(1);
/* create the segment: */
if ((shmid = shmget(key, SHM_SIZE, 0644 | IPC_CREAT)) == -1)
perror("shmget");
exit(1);
/* attach to the segment to get a pointer to it: */
data = shmat(shmid, NULL, 0);
if (data == (char *)(-1))
perror("shmat");
exit(1);
/* read or modify the segment, based on the command line: */
if (argc == 2)
printf("writing to segment: \"%s\"\n", argv[1]);
strncpy(data, argv[1], SHM_SIZE);
else
printf("segment contains: \"%s\"\n", data);
/* detach from the segment: */
if (shmdt(data) == -1)
perror("shmdt");
exit(1);
return 0;
步骤：
使用 ftok 将路径名和项目标识符转换为 System V IPC 密钥
使用 shmget 分配一个共享内存段
使用shmat将shmid标识的共享内存段附加到调用进程的地址空间
对内存区域进行操作
使用 shmdt 分离
【讨论】：
为什么要将 0 转换为 void* 而不是使用 NULL ？ 但是此代码不处理共享内存的删除。程序退出后，必须通过 ipcrm -m 0 手动删除。【参考方案3】：这是一个 mmap 示例：
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/*
* pvtmMmapAlloc - creates a memory mapped file area.
* The return value is a page-aligned memory value, or NULL if there is a failure.
* Here's the list of arguments:
* @mmapFileName - the name of the memory mapped file
* @size - the size of the memory mapped file (should be a multiple of the system page for best performance)
* @create - determines whether or not the area should be created.
*/
void* pvtmMmapAlloc (char * mmapFileName, size_t size, char create)
void * retv = NULL;
if (create)
mode_t origMask = umask(0);
int mmapFd = open(mmapFileName, O_CREAT|O_RDWR, 00666);
umask(origMask);
if (mmapFd < 0)
perror("open mmapFd failed");
return NULL;
if ((ftruncate(mmapFd, size) == 0))
int result = lseek(mmapFd, size - 1, SEEK_SET);
if (result == -1)
perror("lseek mmapFd failed");
close(mmapFd);
return NULL;
/* Something needs to be written at the end of the file to
* have the file actually have the new size.
* Just writing an empty string at the current file position will do.
* Note:
* - The current position in the file is at the end of the stretched
* file due to the call to lseek().
* - The current position in the file is at the end of the stretched
* file due to the call to lseek().
* - An empty string is actually a single '\0' character, so a zero-byte
* will be written at the last byte of the file.
*/
result = write(mmapFd, "", 1);
if (result != 1)
perror("write mmapFd failed");
close(mmapFd);
return NULL;
retv = mmap(NULL, size,
PROT_READ | PROT_WRITE, MAP_SHARED, mmapFd, 0);
if (retv == MAP_FAILED || retv == NULL)
perror("mmap");
close(mmapFd);
return NULL;
else
int mmapFd = open(mmapFileName, O_RDWR, 00666);
if (mmapFd < 0)
return NULL;
int result = lseek(mmapFd, 0, SEEK_END);
if (result == -1)
perror("lseek mmapFd failed");
close(mmapFd);
return NULL;
if (result == 0)
perror("The file has 0 bytes");
close(mmapFd);
return NULL;
retv = mmap(NULL, size,
PROT_READ | PROT_WRITE, MAP_SHARED, mmapFd, 0);
if (retv == MAP_FAILED || retv == NULL)
perror("mmap");
close(mmapFd);
return NULL;
close(mmapFd);
return retv;
【讨论】：
open 增加了文件 I/O 开销。请改用shm_open。
@Spookbuster，在 shm_open 的某些实现中，open() 是在幕后调用的，所以我不得不不同意您的评估；这是一个例子：code.woboq.org/userspace/glibc/sysdeps/posix/shm_open.c.html
虽然一些 shm_open() 实现在后台使用 open()，但 POSIX 对 shm_open() 生成的文件描述符的要求较低。例如，实现不需要支持像 shm_open() 文件描述符的 read() 和 write() 之类的 I/O 函数，允许某些实现对 shm_open() 进行优化，而这些优化不能为 open() 进行。如果你要做的只是 mmap()，你应该使用 shm_open()。
大多数 Linux-glibc 设置通过使用 tmpfs 支持 shm_open() 来进行此类优化。虽然通常可以通过 open() 访问相同的 tmpfs，但没有可移植的方式来了解其路径。 shm_open() 让您以可移植的方式使用该优化。 POSIX 赋予 shm_open() 比 open() 性能更好的潜力。并非所有实现都会利用这种潜力，但它的性能不会比 open() 差。但我同意我关于 open() 总是增加开销的说法过于宽泛。【参考方案4】：
试试这个代码示例，我测试过了，来源：http://www.makelinux.net/alp/035
#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ()
int segment_id;
char* shared_memory;
struct shmid_ds shmbuffer;
int segment_size;
const int shared_segment_size = 0x6400;
/* Allocate a shared memory segment. */
segment_id = shmget (IPC_PRIVATE, shared_segment_size,
IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
/* Attach the shared memory segment. */
shared_memory = (char*) shmat (segment_id, 0, 0);
printf ("shared memory attached at address %p\n", shared_memory);
/* Determine the segment's size. */
shmctl (segment_id, IPC_STAT, &shmbuffer);
segment_size = shmbuffer.shm_segsz;
printf ("segment size: %d\n", segment_size);
/* Write a string to the shared memory segment. */
sprintf (shared_memory, "Hello, world.");
/* Detach the shared memory segment. */
shmdt (shared_memory);
/* Reattach the shared memory segment, at a different address. */
shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0);
printf ("shared memory reattached at address %p\n", shared_memory);
/* Print out the string from shared memory. */
printf ("%s\n", shared_memory);
/* Detach the shared memory segment. */
shmdt (shared_memory);
/* Deallocate the shared memory segment. */
shmctl (segment_id, IPC_RMID, 0);
return 0;
【讨论】：
这是很好的代码，但我认为它没有显示客户端如何访问共享内存段（通过使用来自不同进程的shmget 和shmat），即共享内存的全部意义... =(【参考方案5】：
这些是使用共享内存的包含
#include<sys/ipc.h>
#include<sys/shm.h>
int shmid;
int shmkey = 12222;//u can choose it as your choice
int main()
//now your main starting
shmid = shmget(shmkey,1024,IPC_CREAT);
// 1024 = your preferred size for share memory
// IPC_CREAT its a flag to create shared memory
//now attach a memory to this share memory
char *shmpointer = shmat(shmid,NULL);
//do your work with the shared memory
//read -write will be done with the *shmppointer
//after your work is done deattach the pointer
shmdt(&shmpointer, NULL);
【讨论】：
以上是关于如何在 C 中与 Linux 一起使用共享内存的主要内容，如果未能解决你的问题，请参考以下文章
如何在 c 中使用 posix 命名信号量和 Linux 上两个进程之间的共享内存？
Linux进程间通信--进程，信号，管道，消息队列，信号量，共享内存
在不同步的情况下读写 SysV 共享内存（使用信号量、C/C++、Linux）