如何设置linux的共享内存
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何设置linux的共享内存相关的知识，希望对你有一定的参考价值。
在 Linux 中设置共享内存的方法有很多种，下面是一种常用的方法：
使用shmget()函数创建一块共享内存，可以指定共享内存的大小和标识符。
使用shmat()函数将共享内存连接到进程的地址空间，返回指向共享内存的指针。
使用shmdt()函数断开与共享内存的连接。
使用shmctl()函数删除共享内存。
具体实现可以参考以下代码示例:
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
int main()
// 1. 创建共享内存
int shmid = shmget(IPC_PRIVATE, 100, 0666 | IPC_CREAT);
if (shmid < 0)
perror("shmget error");
return 1;
// 2. 连接共享内存
void *shm = shmat(shmid, NULL, 0);
if (shm == (void *)-1)
perror("shmat error");
return 1;
// 使用共享内存
// ...
// 3. 断开连接
if (shmdt(shm) < 0)
perror("shmdt error");
return 1;
// 4. 删除共享内存
if (shmctl(shmid, IPC_RMID, 0) < 0)
perror("shmctl error");
return 1;
return 0;
这是一个简单的示例，在这里我们创建了一个大小为100字节的共享内存，并使用shmget()、shmat()、shmdt()、shmctl()四个函数来创建、连接、断开连接、删除共享内存。
在实际应用中，我们需要根据需要来调整共享内存的大小，并在使用共享内存时进行相应的同步和互斥操作来保证数据的安全性。
需要注意的是，在使用共享内存时，我们需要确保共享内存在进程全部退出后能够被释放，这可以通过在父进
程中删除共享内存来实现。另外在程序中也要考虑到异常处理，如果在程序运行过程中发生了异常，应该及时释放所占用的共享内存，以免造成资源浪费。
另外需要提醒的是，共享内存是一种高级的IPC(Inter-Process Communication)机制，使用时需要谨慎，避免出现数据竞争和死锁等问题。
参考技术A 我们可以修改shmmax内核参数，使SGA存在于一个共享内存段中。通过修改/proc/sys/kernel/shmmax参数可以达到此目的。
[root@neirong root]# echo 1073741824 > /proc/sys/kernel/shmmax
[root@neirong root]# more /proc/sys/kernel/shmmax
1073741824这里设为1G。
对于shmmax文件的修改，系统重新启动后会复位。可以通过修改 /etc/sysctl.conf 使更改永久化。
在该文件内添加以下一行 kernel.shmmax = 1073741824 这个更改在系统重新启动后生效.
1、设置 SHMMAX
SHMMAX
参数定义共享内存段的最大尺寸（以字节为单位）。在设置 SHMMAX 时，切记 SGA 的大小应该适合于一个共享内存段。 SHMMAX 设置不足可能会导致以下问题：
ORA-27123:unable to attach to shared memory segment
您可以通过执行以下命令来确定 SHMMAX 的值：
# cat /proc/sys/kernel/shmmax
33554432
SHMMAX 的默认值是 32MB 。我一般使用下列方法之一种将 SHMMAX 参数设为 2GB ：
通过直接更改 /proc 文件系统，你不需重新启动机器就可以改变 SHMMAX 的默认设置。我使用的方法是将以下命令放入 /etc/rc.local 启动文件中：
# >echo "2147483648" > /proc/sys/kernel/shmmax
您还可以使用 sysctl 命令来更改 SHMMAX 的值：
# sysctl -w kernel.shmmax=2147483648
最后，通过将该内核参数插入到 /etc/sysctl.conf 启动文件中，您可以使这种更改永久有效：
# echo "kernel.shmmax=2147483648" >> /etc/sysctl.conf
2、设置 SHMMNI
我们现在来看 SHMMNI 参数。这个内核参数用于设置系统范围内共享内存段的最大数量。该参数的默认值是 4096 。这一数值已经足够，通常不需要更改。
您可以通过执行以下命令来确定 SHMMNI 的值：
# cat /proc/sys/kernel/shmmni
4096
3、设置 SHMALL
最后，我们来看 SHMALL 共享内存内核参数。该参数控制着系统一次可以使用的共享内存总量（以页为单位）。简言之，该参数的值始终应该至少为：
ceil(SHMMAX/PAGE_SIZE)
SHMALL 的默认大小为 2097152 ，可以使用以下命令进行查询：
# cat /proc/sys/kernel/shmall
2097152
SHMALL 的默认设置对于我们的 Oracle9 i RAC 安装来说应该足够使用。
注意： 在 i386 平台上 Red Hat Linux 的 页面大小 为 4096 字节。但是，您可以使用 bigpages ，它支持配置更大的内存页面尺寸。
如何在 C 中与 Linux 一起使用共享内存
【中文标题】如何在 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);
【讨论】：
以上是关于如何设置linux的共享内存的主要内容，如果未能解决你的问题，请参考以下文章