【Linux详解】——共享内存

最新推荐文章于 2024-07-15 02:00:21 发布
最新推荐文章于 2024-07-15 02:00:21 发布
阅读量1.5k 收藏 5
点赞数
分类专栏： Linux详解 文章标签： linux 服务器 笔记 学习
❗ 转载请注明出处 作者：HinsCoder 博客链接：
本文链接：https://blog.csdn.net/HinsCoder/article/details/132029743
版权

📖 前言：本期介绍共享内存。

目录

🕒 1. 共享内存的原理

在之前学过的进程地址空间的基础上，我们知道，进程之间具有独立性，因为每个进程的内核数据结构的数据以及页表的映射都是独立的。而对于共享内存，我们同样了解，这是为了让进程之间能够进行通信的公共空间，接下来就通过进程地址空间的结构去了解共享空间的位置及原理：
在这里插入图片描述

OS为了让两个毫不相关的进程之间进行通信，进行了三个工作：

  1. 在对应的内存当中让用户帮OS申请一块空间（通过指定的调用接口）
  2. 将创建好的内存映射进进程的地址空间（用户就可以通过访问起始地址的方式来进行对申请的这块内存空间的访问）
  3. 未来不想通信：
    • 取消进程和内存的映射关系
    • 释放内存

因此，我们把申请的这块空间称之为共享内存，将映射关系称之为进程和共享内存进行挂接。将取消进程和内存的映射关系称之为去关联，释放内存释放的就是共享内存。

理解：

  • 进程间通信，是专门设计的，用来IPC的，和malloc/new不是一个东西。
  • 共享内存是一种通信方式，所有想通信的进程，都可以用。
  • OS中一定会存在着很多共享内存。

🕒 2. 共享内存的概念

通过让不同的进程，看到同一个内存块的方式，叫做共享内存。

🕘 2.1 接口认识

#include<sys/ipc.h>
#include<sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);// size:共享内存的大小

对于shmflg，常见的有两种选择：

  • IPC_CREAT：如果不存在共享文件则创建，存在则获取
  • IPC_EXCL：
    • 无法单独使用，单独使用没有意义，需要结合IPC_CREAT
    • IPC_CREAT|IPC_EXCL：如果不存在，就创建，如果已存在，就出错返回。即在用户的角度，如果创建成功，一定是一个新的shm！

shmget返回值： 记住他是一个标识符就够用了，得到的是共享内存的标识符。（和文件fd没有任何关系）

key： 是什么不重要，最重要的是其具备的唯一性。

而获取key值，则通过一个新的接口：ftok ，ftok通过指定的字符串数据*pathname以及char类型的proj_id数据进行一系列的算法整合返回了具有唯一性的Key:

key_t ftok(char *pathname, char proj_id);

由于创建的key值有可能已经被别人使用了，因此有失败的可能性。创建Key值如果失败，则返回-1。

🕘 2.2 演示生成key的唯一性

# Makefile
.PHONY:all
all:shm_client shm_server

shm_client:shm_client.cc
	g++ -o $@ $^ -std=c++11
shm_server:shm_server.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -f shm_client shm_server

// comm.hpp
#ifndef _COMM_HPP_
#define _COMM_HPP_

#include<iostream>
#include<cerrno>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<sys/ipc.h>
#include<sys/shm.h>

#define PATHNAME "."//当前路径
#define PROJ_ID 0x66

key_t getKey()
{
    key_t k = ftok(PATHNAME, PROJ_ID);
    if(k < 0)
    {
        // cin, cout, cerr ->stdin, stdout, stderr->0, 1, 2;标准错误stderr向2打印。
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(1);//终止进程
    }
    return k;
}

#endif

// shm_server.cc
#include"comm.hpp"

int main()
{
    key_t k = getKey();

    printf("0x%x\n", k);
    return 0;
}

// shm_client.cc
#include"comm.hpp"

int main()
{
    key_t k = getKey();

    printf("0x%x\n", k);
    return 0;
}

[hins@VM-12-13-centos shm]$ ./shm_server
0x6601062a
[hins@VM-12-13-centos shm]$ ./shm_client
0x6601062a

通过make后执行发现，两个程序的k值是一样的，这就证明了ftok指定参数的返回值是唯一的。（k实际上就是32位的一个整数）

🕘 2.3 再谈key

OS中一定存在多个共享内存，因为彼此之间可能都需要通信，因此也就都需要申请一块空间。而OS申请的共享空间，也一定和进程一样需要被管理，既然需要管理，那么一定也是先描述再组织的方式，即共享内存 = 物理内存块+共享内存的相关属性 。

之前谈到过，key是什么不重要，能进行唯一性的标识最重要，因此创建共享内存的时候，是如何保证共享内存在系统中是唯一的呢？当然是通过key来确定的，只要一个进程也看到了同一个key，就能够访问这个共享内存。那么key在哪里，实际上这就和PCB一样，key就在内核中的属性集合里，即：

struct shm{
    key_t key;
    //...
}

即：key是通过shmget这样的系统调用，设置进入共享内存属性中，用来表示该共享内存在内核中的唯一性！

shmid和key就好比fd和inode。为什么有了key还需要shmid呢？通过key和shmid的区分，能够面向系统层面和用户层面，这样能够更好的进行解耦，以免内核中的变化影响到用户级。

🕒 3. 共享内存相关命令

通过让不同的进程，看到同一个内存块的方式，叫做共享内存。

查看共享内存：ipcs -m/-q/-s （共享内存/消息队列/信号量数组）

删除共享内存：ipcrm -m shmnid

将共享内存与虚拟内存进行关联:

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);// 共享内存id，被映射的进程地址空间（给nullptr），给0默认可以读写。成功时，将返回共享内存的虚拟地址。失败返回-1（失败错误码errno被设置）

将共享内存与虚拟内存去关联：

#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);//参数：shmat的返回值。成功时，将返回0。失败返回-1（失败错误码errno被设置）

控制（主要用移除）共享内存（shmctl）：

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);//shmid(类似fd),传入系统设定的宏，shmid_ds数据结构。传入IPC_RMID移除共享内存成功时，将返回0。失败返回-1（失败错误码errno被设置）

🕒 4. 利用共享内存进行进程间通信

// comm.hpp
#pragma once
#include <iostream>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
 
 
#define PATHNAME "."//当前路径（路径都行）
#define PROJ_ID 0X55//项目id也无要求
#define MAX_SIZE 4096
key_t getKey()
{
    key_t k=ftok(PATHNAME, PROJ_ID);
    if(k==-1)
    {
        std::cout<<"ftok"<<errno<<":"<<strerror(errno)<<std::endl;
        exit(1);
    }
    return k;
}
int getShmHelper(key_t key,int flags)
{
    int shmid=shmget(key,MAX_SIZE,flags);
    if(shmid==-1)//创建共享内存失败
    {
        std::cerr<<"shmget"<<errno<<":"<<strerror(errno)<<std::endl;
        exit(2);
    }
    return shmid;//返回共享内存标识符
}
int getShm(key_t key)//创建||获取共享内存
{
    return getShmHelper(key,IPC_CREAT);//传0也行
}
int createShm(key_t key)//必定创建共享内存
{
    return getShmHelper(key,IPC_CREAT|IPC_EXCL|0600);//生成一个全新的共享内存
}
void* attachShm(int shmid)//让共享内存与虚拟内存建立联系
{
    void* memstart=shmat(shmid,nullptr,0);
    if((long long)memstart==-1L)
    {
        std::cerr<<"shmat"<<errno<<":"<<strerror<<std::endl;
        exit(3);
    }
    return memstart;
} 
void detchShm(void* memStart)//去关联
{
    if(shmdt(memStart)==-1)
    {
        std::cerr<<"shmdt"<<errno<<":"<<strerror<<std::endl;
        exit(4);
    }
}   
void delShm(int shmid)//删除共享内存
{
    if(shmctl(shmid,IPC_RMID,nullptr)==-1)
    {
        std::cerr<<"shmctl"<<errno<<":"<<strerror<<std::endl;
    }
}

// shm_server.cc
#include "comm.hpp"
int main()
{
    key_t k=getKey();
    printf("0X%x\n",k);
    int shmid=createShm(k);
 
    char* memStart=(char*)attachShm(shmid);//让共享内存与虚拟内存建立联系
    printf("memStart address:%p\n",memStart); 
 
    //通信接收代码
    while(true)
    {
        printf("client say:%s\n",memStart); 
        sleep(1);
 
        //调用用户级结构体
        struct shmid_ds ds;//创建结构体对象ds
        shmctl(shmid,IPC_STAT,&ds);//获取ds对象的状态
        printf("获取属性：%d,pid:%d,myself:%d,key:%d\n",ds.shm_segsz,getpid(),ds.shm_cpid,ds.shm_perm.__key);
    }
 
 
    detchShm(memStart);//去关联
    sleep(10);
 
    delShm(shmid);//删除共享内存,client和server都能删除共享内存，尽量谁创建谁删
    return 0;
}

// shm_client.cc
#include "comm.hpp"
int main()
{
    key_t k=getKey();
    printf("0X%x\n",k);
    int shmid=getShm(k);//获取共享内存
    sleep(5);
 
    char* memStart=(char*)attachShm(shmid);//让共享内存与虚拟内存建立联系
    printf("memStart address:%p\n",memStart); 
 
    //通信传输代码
    const char* massage="I am client";
    pid_t id=getpid();
    int cnt=0;//发送计数
    while(true)
    {
        snprintf(memStart,MAX_SIZE,"%s[%d]:%d\n",massage,getpid,++cnt);
        sleep(1);
    }
 
    detchShm(memStart);//去关联
    return 0;
}

🕒 5. 共享内存的优缺点

优点：共享内存是所有进程间通信中速度最快的。（无需缓冲区，能大大减少通信数据的拷贝次数）

缺点：如果服务端读取速度较快，用户端发送数据较慢，就会产生同一段消息被服务端读取多遍。共享内存是不进行同步和互斥的，没有对数据进行任何保护。

共享内存大小的建议：因为系统分配共享内存是以4KB为基本单位，一般建议申请共享内存的大小为4KB的整数倍。

OK，以上就是本期知识点“共享内存”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟📌~
💫如果有错误❌，欢迎批评指正呀👀~让我们一起相互进步🚀
🎉如果觉得收获满满，可以点点赞👍支持一下哟~

❗ 转载请注明出处
作者：HinsCoder
博客链接：🔎 作者博客主页

HinsCoder
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 共享内存
06-26
linux华清远见 实验正确代码，共享内存，修改了其中错误的代码。
详解Linux进程间通信——使用共享内存
09-15
共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。这篇文章主要介绍了详解Linux进程间通信——使用共享内存，有兴趣的可以了解一下。
linux共享内存
弹-room
11-03 596
共享内存共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。 快速本地通信 因为所有进程共享同一块内存，共享内存在各种进程间通信方式中具有最高的效率。访问共享内存区域和访问进程独有的内存区域一样快，并不需要通过系统
关于共享内存
最新发布
weixin_45484608的博客
07-15 688
共享内存的实现依赖于缓存一致性协议和操作系统提供的同步机制，由此确保多核或多线程的正确访问。
linux 共享内存_进程间通信 共享内存
weixin_39804629的博客
11-30 485
在Linux系统中，每个进程都有独立的虚拟内存空间，也就是说不同的进程访问同一段虚拟内存地址所得到的数据是不一样的，这是因为不同进程相同的虚拟内存地址会映射到不同的物理内存地址上。但有时候为了让不同进程之间进行通信，需要让不同进程共享相同的物理内存，Linux通过共享内存来实现这个功能。下面先来介绍一下Linux系统的共享内存的使用。共享内存使用1. 获取共享内存要使用共享内存，首先...
详解Linux进程间通信——使用信号量
09-15
### 详解Linux进程间通信——使用信号量 #### 一、什么是信号量 信号量是一种常用的同步机制，用于解决多进程或线程并发访问共享资源时可能出现的竞争条件问题。在多进程环境中，当多个进程尝试同时访问同一个共享...
共享内存
diechi0288的博客
07-26 285
效率：采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据[1]： 一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建 立共享内存区域。而是保持共享区...
Linux开发基础：命令详解——cvs添加与删除
开发者们共享资源，创建并发布软件，这得益于自由软件基金会的GNU认证授权，使得软件能够免费且广泛地被使用。 接着，文章提到了Linux程序设计的基础，包括使用文本编辑器vi，理解Linux下的函数库，以及如何使用GCC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值