41.Linux 共享内存

最新推荐文章于 2024-03-29 17:30:27 发布
最新推荐文章于 2024-03-29 17:30:27 发布
阅读量235 收藏
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57908316/article/details/121040795
版权
本文详细介绍了如何使用IPC（Inter-Process Communication）中的共享内存进行进程间通信。从shmget函数创建共享内存对象，ftok生成key，到shmat将内存映射到用户空间，再到shmdt解除映射和shmctl删除内存，最后展示了父子进程及无亲缘关系进程间的通信实例。内容涵盖了共享内存的基本操作及其在实际通信中的应用。
摘要由CSDN通过智能技术生成

                                                IPC和文件IO函数的比较 

文件I/OIPC
open

Msg_get

Shm_get

Sem_get

read

write

msgsnd  msgrecv

shmat     shmdt

semop

close

msgctrl

shmctrl

semctrl

打开或创建一个共享内存对象，共享内核在内核是什么样子的？

一块缓存，变类似于用户空间的数组或malloc函数分配的空间一样

所需头文件

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/shm.h>

函数原型int shmget(key_t key,int size,int shmflg);
函数参数key:IPC_PRIVATE（私有的）或ftok的返回值
size:共享内存区大小
shmflg：同open函数的权限位，也可以用8进制表示法
函数返回

成功：共享内存段标识符——ID——文件描述符

失败：-1

查看IPC对象      ipcs      -m（共享内存）         -q（消息队列）       -s（信号灯）

删除IPC对象      ipcrm   -m   id

返回值：共享内存段标识符        IPC的ID 号

通过程序来理解shmget函数的用法（第一个IPC_PRIVATE来获得）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
int main()
{
	int shmid;
	shmid=shmget(IPC_PRIVATE,128,0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	system("ipcs -m");
	//system("ipcrm -m shmid");
	return 0;
}

执行结果如下：

通过IPC_PRIVATE创建的宏key始终等于0.，可以实现有亲缘关系之间的通信

shmget类似文件IO中的open函数，会在内核中创建一个对象，我们称之为共享内存，而共享内存就是一个内核中的缓存，这个缓存就像是一个数组。 

①key：第一个IPC_PRIVATE来获得，第二个通过ftok函数的返回值获得

②大小：

③权限

2.ftok函数：创建key的值。

char ftok(const char *path,char key);

参数：第一个参数：文件路径和文件名

          第二个参数：  一个字符

返回值：正确返回一个key值，出错返回-1.

ftok函数可以实现无亲缘关系之间的通信。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
int main()
{
	int shmid;
	key_t key;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("creat key failure\n");
		return -2;
	}
	printf("creat key sucess key=%X\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	system("ipcs -m");
	//system("ipcrm -m shmid");
	return 0;
}

执行结果如下：

 发现key值这个时候再也不等于0

IPC_PRAVATE操作时，共享内存的key值都一样，都是0，所以使用ftok来创建key值。只要key值是一样的，用户空间的进程通信这个函数打开，则会对内核的同一个IPC对象操作。

（3）shmat函数  将共享内存映射到用户空间的地址中

能不能用read，write呢？

为了方便用户空间对共享内存的操作，使用地址映射的方式。

类似于malloc

void *shmat(int shmid,const void *shmaddr,int shmflg);

参数：第一个参数：ID号

           第二个参数：映射到的地址，NULL为系统自动完成的映射；

           第三个参数shmflg：SHM_RDONLY共享内存只读

                                           默认是0，表示共享内存可读写。

返回值：成功：映射后的地址；

失败：NULL。

 程序：shmat的设计

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
int main()
{
	int shmid;
	key_t key;
	char *p;
	key=ftok("./a.c",'a');

	if(key<0)
	{
		printf("creat key failure\n");
		return -2;
	}
	printf("creat key sucess key=%X\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	system("ipcs -m");
	
	p=(char *)shmat(shmid,NULL,0);
	if(p==NULL)
	{
		printf("shmat function failure\n");
		return -3;
	}
	fgets(p,128,stdin);

	//start read_share_memory
	printf("share memory data:%s\n",p);

	return 0;
}

  执行后的结果为：

 共享内存的特点：

-共享内存创建后，一直存在于内核中，直到被删除或系统关闭

-共享内存和管道不一样，读取后，内容仍在其共享内存中。

不过用完了共享内存之后，就释放

（4）shmdt：将用户空间进程里的地址映射删除。

int shmdt(const void *shmaddr);

参数：shmaddr共享内存映射后的地址

返回值：成功：0

              失败：-1  

shmdt函数的用法

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
int main()
{
	int shmid;
	key_t key;
	char *p;
	key=ftok("./a.c",'a');

	if(key<0)
	{
		printf("creat key failure\n");
		return -2;
	}
	printf("creat key sucess key=%X\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	system("ipcs -m");
	
	p=(char *)shmat(shmid,NULL,0);
	if(p==NULL)
	{
		printf("shmat function failure\n");
		return -3;
	}
	fgets(p,128,stdin);

	//start read_share_memory
	printf("share memory data:%s\n",p);
	
	printf("second share memory data:%s\n",p);

	shmdt(p);
	memcpy(p,"abcd",4);

	return 0;
}

执行结果如下：

 发生段错误，因为内存已经被释放

（5）shmctl函数：删除内核空间共享内存对象

函数原型：int shmctl(int shmid,int cmd,struct shmid_ds *buf);

函数参数：shmid：要操作的共享内存标识符

                  cmd：IPC_STAT（获取对象属性）——实现了命令ipcs -m

                            IPC_SET（设置对象属性）                          

                            IPC_RMID（删除对象）      ——实现了命令ipcrm  -m  

                  buf：指定IPC_STAT/IPC_SET时用于保存/设置属性。

函数返回值：成功：0

                      失败：-1    

ipcs -m:查看内核空间共享内存对象

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
int main()
{
	int shmid;
	key_t key;
	char *p;
	key=ftok("./a.c",'a');

	if(key<0)
	{
		printf("creat key failure\n");
		return -2;
	}
	printf("creat key sucess key=%X\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	system("ipcs -m");
	
	p=(char *)shmat(shmid,NULL,0);
	if(p==NULL)
	{
		printf("shmat function failure\n");
		return -3;
	}
	fgets(p,128,stdin);

	//start read_share_memory
	printf("share memory data:%s\n",p);
	
	printf("second share memory data:%s\n",p);

	shmdt(p);
	
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
}

执行结果如下：

 共享内存被删除了

使用我们前面学到的知识构建ipcs -m和ipcrm -m这两个命令

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
int main(int argc,char *argv[])
{
	int shmid;
	if(argc<3)
	{
		printf("please input param\n");
		return -1;
	}	
	if(strcmp(argv[1],"-m")==0)
		printf("delete share memory ");
	else
		return -2;
	shmid=atoi(argv[2]);
	printf("shmid=%d\n",shmid);
	shmctl(shmid,IPC_RMID,NULL);	
	system("ipcs -m");
	return 0;
}

执行结果如下：

父子进程之间的共享内存通信（IPC_PRIVATE）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
void myfunc(int signum)
{
	return;
}
int main()
{
	int shmid;
	char *p;
	pid_t pid;
	shmid=shmget(IPC_PRIVATE,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	
	pid=fork();
	if(pid>0)
	{
		signal(SIGUSR2,myfunc);
		p=(char *)shmat(shmid,NULL,0);
		if(p==NULL)
		{
			printf("parent process : shmat function failure\n");
			return -3;
		}
		while(1)
		{
			printf("parent process start write share memory:\n");
			fgets(p,128,stdin);
			kill(pid,SIGUSR1);//child process read data
			pause();//wait child process read
		}
	}
	if(pid==0)//child process
	{
		signal(SIGUSR1,myfunc);
		p=(char *)shmat(shmid,NULL,0);
		if(p==NULL)
		{
			printf("child process : shmat function failure\n");
			return -3;
		}
		while(1)
		{
			pause();//wait parent process write
			//start read_share_memory
			printf("share memory data:%s\n",p);
			kill(getppid(),SIGUSR2);
		}
	}

	shmdt(p);
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
}

执行结果如下：

 

无亲缘关系进程之间的通信（必须使用ftok函数），server.c发送信号，client.c接收信号

server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
struct mybuf{
	int pid;
	char buf[124];
};

void myfunc(int signum)
{
	return;
}
int main()
{
	int shmid;
	struct mybuf *p;
	int key;
	pid_t pid;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("creat key failure\n");
		return -1;
	}
	printf("creat key sucess\n");
	shmid=shmget(key,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	
	

		signal(SIGUSR1,myfunc);
		p=(struct mybuf *)shmat(shmid,NULL,0);
		if(p==NULL)
		{
			printf("parent process : shmat function failure\n");
			return -3;
		}
		//get server pid
		//read share memory
		pid=p->pid;
		//write client pid to share memory
		p->pid=getpid();
		//kill signal
		kill(pid,SIGUSR2);

		//client start read data from share memory
		while(1)
		{
			pause();//wait server write data to share memory;
			printf("client process receive data from share memory:%s",p->buf);//read data
			kill(pid,SIGUSR2);//server may write share memory
		}
	

	shmdt(p);
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
struct mybuf{
	int pid;
	char buf[124];
};

void myfunc(int signum)
{
	return;
}
int main()
{
	int shmid;
	struct mybuf *p;
	int key;
	pid_t pid;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("creat key failure\n");
		return -1;
	}
	printf("creat key sucess\n");
	shmid=shmget(key,128,IPC_CREAT|0777);
	if(shmid<0)
	{
		printf("creat share memory failure\n");
		return -1;
	}
	printf("creat share memory sucess shmid=%d\n",shmid);
	
	

		signal(SIGUSR2,myfunc);
		p=(struct mybuf *)shmat(shmid,NULL,0);
		if(p==NULL)
		{
			printf("parent process : shmat function failure\n");
			return -3;
		}
		//get client pid
		p->pid=getpid();//write server pid to share memory
		
		pause();//wait client read server pid;

		pid=p->pid;

		//write
		while(1)
		{
			printf("parent process start write share memory:\n");
			fgets(p->buf,128,stdin);
			kill(pid,SIGUSR1);//client process read data
			pause();//wait client process read
		}
	

	shmdt(p);
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
}

执行结果如下：

 

STM32李逼
关注
Linux内核入门（十）——进程间通信：共享内存
qq_38406667的博客
06-25 773
Linux内核入门（十）——进程间通信：共享内存前言什么是共享内存创建一块共享内存代码测试 前言 上回书说到信号，七七八八的东西比较多，相比之下，共享内存就没那么多弯弯绕绕了，共享内存的使用思路和前面讲的管道通信比较像，我们来看看 什么是共享内存 顾名思义：共享内存本质是一段内存，它存在于内核空间，由用户创建和销毁，不同进程可以共同访问同一段共享内存。 这里就有个问题，共享内存谁都可以来随时读写，万一同时有两个进程同时在读写同一段共享内存咋办？这不得打起来？共享内存是不提供同步机制的，所以作为程序员需要编写
Linux共享内存二维数组,linux系统编程--shmget shmat shmdt
weixin_29144347的博客
05-01 302
要使用共享内存，应该有如下步骤：1.开辟一块共享内存 shmget()2.允许本进程使用共某块共享内存 shmat()3.写入/读出4.禁止本进程使用这块共享内存 shmdt()5.删除这块共享内存 shmctl()或者命令行下ipcrmftok()。它有两个参数，一个是字符串，一个是字符。字符串一般用当前进程的程序名，字符一般用来标记这个标识符所标识的共享内存是这个进程所开辟的第几个共享内存。f...
Linux之共享内存
qq_46135211的博客
02-24 2741
Linux之共享内存
Linux——共享内存
最新发布
qq_67693066的博客
03-29 1546
Linux——共享内存
linux共享内存 dest,详解Linux共享内存的管理
weixin_39604139的博客
04-30 545
在进程通信应用中会用到共享内存，这就涉及到了IPC，与IPC相关的命令包括：ipcs、ipcrm(释放IPC)。IPCS命令是Linux下显示进程间通信设施状态的工具。我们知道，系统进行进程间通信(IPC)的时候，可用的方式包括信号量、共享内存、消息队列、管道、信号(signal)、套接字等形式[2]。使用IPCS可以查看共享内存、信号量、消息队列的状态。当下系统是Ubuntu Linux 18....
shm.tar.gz_Linux共享内存_共享内存_内存共享 linux
09-23
运行程序，可在linux下创建指定共享内存名，指定大小的共享内存，用于检测此名称此大小的共享内存在linux系统下是否能创建成功
cpu_usage.rar_Linux共享内存
09-14
"cpu_usage.rar_Linux共享内存"是一个针对Linux系统的工具，用于统计CPU的使用情况，而且特别强调了采用共享内存的方式来实现。这个工具的设计旨在提高效率，减少不必要的I/O操作，因为共享内存允许多个进程之间快速...
sem.rar_linux内存共享
09-24
本资源“sem.rar_linux内存共享”聚焦于一种高效且直接的IPC方式——共享内存，以及配合使用的同步原语——信号量。共享内存允许不同进程访问同一块内存区域，而信号量则用于控制对这部分内存的访问权限，防止数据...
SUIDAO.zip_Linux共享内存_隧道
09-21
Linux内核分析实验 本实验实现车辆过隧道的模拟，其中最关键的是信号灯实现进程同步以及共享内存的实现。
posix_shm.rar_Linux共享内存
09-23
在linux下，实现的Posix的共享内存，从一个文件拷贝到另一个文件
共享内存的属性结构体
06-09
共享内存的属性结构体 struct shmid_ds
linux c 共享内存读写操作
05-17
【需求描述】 1、共享内存保存信息 2、提供接口写入共享内存 3、提供接口获取共享内存 【编写语言:C】 【环境：linux】 1、写入内存一千万条数据 耗时:5.356秒 2、读取内存一千万条数据 耗时:1.449秒
linux如何更改共享内存,如何设置LINUX的共享内存
weixin_32673065的博客
04-30 176
我们可以修改shmmax内核参数，使SGA存在于一个共享内存段中。通过修改/proc/sys/kernel/shmmax参数可以达到此目的。[root@neirong root]# echo 1073741824 >/proc/sys/kernel/shmmax[root@neirong root]# more /proc/sys/kernel/shmmax1073741824这里设为1G。...
关于STM32H745xI双核的SRAM内存分配问题
qq_34985000的博客
03-13 2803
最近工程中遇到的一些问题，做个笔记 M7的共享内存不能是0x3000_0000开头的SRAM1，因为如果让这个地址写东西，就相当于覆盖了M4的RAM(0x1000_0000)， 实验现象是，我M7内核往0x3000_0000写数据，结果M4的SystemD2Clock全局变量和struBitOutput_M4会默认的被修改，struBitOutput_M4被修改，所以Q01被输出，软启动莫名开启。 手册上的一些说明： M7运行内存(0x2400_0000到0x2407_FFFF)一共512K M4运行内存
Apache重启失败name-based shared memory failure
weixin_33907511的博客
11-18 363
2019独角兽企业重金招聘Python工程师标准>>> ...
IPC之共享内存
weixin_44522306的博客
04-27 1246
1.使用共享内存一般步骤 ： 1.1获得共享内存对象的ID：shmget() 1.2将共享内存映射至本进程虚拟内存空间的某个区域：shmat() 1.3当不适用时，解除映射关系shmdt() 1.4当所有进程都不用共享内存之时，删除共享内存shmctl() 2. 共享内存的创建函数shmget 注意： 参数 key：IPC_PRIVATE 或 ftok的返回值，IPC_PRIVATE会生成相同...
高通平台aboot通过shared memory保存uart log到kernel
RyanLiu_的博客
12-28 2389
文档目的 shared memory即共享内存，在不同的进程之间通过一小段内存来共享信息，实现进程间通信。本文主要介绍高通aboot(lk) 和内核(kernel)间的信息传递。 在传统的lk-》kernel信息传递使用的是cmdline，但是这种方法只适合传递简短的信息，对于很大段的信息(比如aboot中的所有uart log)却无法传递。所以此处我们使用共享内存来传递，先把aboot中ua
linux进程间通信(IPC) --- 共享内存
weixin_52495715的博客
12-27 583
共享内存概述 共享内存允许两个或者多个进程共享给定的存储区域 共享内存的特点 1.共享内存是进程间共享数据的一种最快的方法 一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容 2.使用共享内存要注意的是多个进程之间对一个给定存储区访问的互斥 若一个进程正在向共享内存区写数据，则在它做完这一步操作前，别的进程不应当去读，写这些数据。 上面图片讲解： 左右两边每一个进程在创建的时候，都会给它分配4G的虚拟内存，所以左右两边的空间叫做虚拟内存，而中间的是物理内存，也就是内存条
stm32f1--IAP
void__void的博客
05-14 775
系列文章目录 STM32--IAP升级 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 本文编译环境为Truestudio，简单介绍STM32IAP升级的方法 一、IAP是什么？ IAP是In Application Programming的首字母缩写，IAP是用户自己的程序在运行过程中对User Flash的部分区域进行烧写，目的是..
Linux System V共享内存深入解析
“Linux下的共享内存是一种高效的进程间通信（IPC）机制，允许多个进程直接访问同一块内存区域，避免了数据在内核和用户空间之间的拷贝，提高了通信效率。System V IPC提供了三种机制：消息队列、信号量和共享内存。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值