Linux：进程间通信-＞共享内存

1. 共享内存的概念

System V共享内存，是一个高效的进程间通信IPC机制，允许多个进程共享同一块物理内存区实现快速的数据交换。如下图所示 

 这两个进程分别通过页表映射到这一块共享内存中

2. 共享内存的函数

shmget

功能： 创建新的共享内存段，或获取已经存在的共享内存标识符(shmid)

头文件和原型如下

#include <sys/shm.h>int shmget(key_t key, size_t size, int shmflg);

参数如下：

1. key：共享内存的唯一键值(由ftok生成或IPC_PRIVATE)

2. size：共享内存的大小(字节)，创建时必须指定，获取已有的共享内存可设为0。

3. shmflg：权限标识(例如0666)，可用权限如下

        IPC_CREAT：如果不存在就创建新段

        IPC_EXCL：与IPC_CREAT一起使用，若段已存在则失败。

        SHM_HUGETLB：使用大页内存(需要内核支持)

返回值：成功返回共享内存标识符(shmid),失败返回-1，错误码存在error

 shmat

功能：将共享内存段附加到当前进程的地址空间，返回指向共享内存的指针。

原型：

#include <sys/shm.h>void *shmat(int shmid, const void *shmaddr, int shmflg);

参数：

1. shmid：共享内存标识符

2. shmaddr：指定附加地址(通常设为NULL)

3. shmflg：选项如下

        SHM_RDONLY：以只读模式附加

        SHM_REMAP(Linux特供)：替换现有映射

返回值：成功返回共享内存的起始地址指针，失败返回(void*) -1

 shmdt

功能：将共享内存段从当前进程的地址空间分离

int shmdt(const void *shmaddr);

参数：

shmaddr：shmat返回的指针

返回值： 成功返回0，失败返回-1

shmctl

在linux下可以用下面指令删除

ipcrm -m shmid

功能：对共享内存段执行控制操作(删除、查询状态)

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

参数：

1. shmid：共享内存标识符

2. cmd：控制命令，选项如下

        IPC_RMID：标记共享内存段为待删除(所有进程分离后销毁)

        IPC_STAT：获取共享内存段的状态信息

        IPC_SET：修改共享内存段的权限或所有者

3. buf：指向struct shmid_ds的指针，用于存储或设置状态信息

返回值：成功返回0，失败返回-1设置错误信息errno

 ftok函数生成键值

功能：根据文件路径和项目标识符生成唯一键值(key_t)

功能和头文件

#include <sys/ipc.h>key_t ftok(const char *pathname, int proj_id);

参数：
1. pathname：一个存在的文件路径(例如/tmp/shmfile)。

2. proj_id：项目标识符(一个字节，通常用一个字符)

返回值：成功返回生成的键值，失败返回-1

 3. 共享内存通信

#define ERR_EXIT(m)  \
do \
{  \perror(m);  \exit(EXIT_FAILURE); \
}while(0)  \//处理错误的宏  

写端创建共享内存

        int _k = ftok(".", 48);_size= 4096;       _shmid=shmget(_k,_size,IPC_CREAT|IPC_EXCL|0666);if(_shmid<0){ERR_EXIT("shmid");}

读端获取共享内存

        int _k = ftok(".", 48);_size= 4096;       _shmid=shmget(_k,_size,IPC_CREAT);if(_shmid<0){ERR_EXIT("shmid");}

获取指向共享内存的指针

获取指向共享内存的指针

        _start_mem=shmat(_shmid,nullptr,0);if((long long)_start_mem<0){std::cout<<"shmat 失败"<<std::endl;ERR_EXIT("shmat");}

将指针与共享内存分离

进程退出时没解除绑定，共享内存段就仍然保留在系统的共享内存资源中，直到shmctl或系统重启

        int n=shmdt(_start_mem);//将指针与共享内存分离if(n==0)//成功{printf("shmctl delete shm: %d success!\n",_shmid);}else{ERR_EXIT("shmdt");}

共享内存也采用引用计数，shmdt成功时，引用计数-1

查看共享内存

#include <sys/shm.h>struct shmid_ds {struct ipc_perm shm_perm;   // 权限和所有者信息size_t          shm_segsz;  // 共享内存段大小（字节）time_t          shm_atime;  // 最后附加时间（attach）time_t          shm_dtime;  // 最后分离时间（detach）time_t          shm_ctime;  // 最后修改时间（创建或属性变更）pid_t           shm_cpid;   // 创建者进程的PIDpid_t           shm_lpid;   // 最后操作（attach/detach）的进程PIDshmatt_t        shm_nattch; // 当前附加到该段的进程数// ... 其他系统特定字段（可能因操作系统不同而扩展）
};struct ipc_perm {key_t   __key;    // 共享内存的键值（ftok生成）uid_t   uid;      // 所有者的用户IDgid_t   gid;      // 所有者的组IDuid_t   cuid;     // 创建者的用户IDgid_t   cgid;     // 创建者的组IDunsigned short mode;  // 权限标志（如0666）unsigned short __seq; // 序列号（内核使用）
};

进程结束后共享内存不会销毁，导致资源泄露

        struct shmid_ds ds;//结构体int n=shmctl(_shmid,IPC_STAT,&ds);printf("shm_segsz: %ld\n",ds.shm_segsz);printf("key: 0x%x\n",ds.shm_perm.__key);

IPC_STAT通过shmctl获取共享内存段的元数据(存入我们存入的struct shmid_ds结构体)

销毁共享内存

        //_shmid=shmget(_k,_size,IPC_CREAT|IPC_EXCL|0666);//_shmid值如上所示if(_shmid==gdefaultid) return;//没初始化int n=shmctl(_shmid,IPC_RMID,nullptr);if(n==0)//删除成功返回0{int n=shmdt(_start_mem);//将指针与共享内存分离if(n==0)//成功{printf("shmctl delete shm: %d success!\n",_shmid);}else{ERR_EXIT("shmdt");}}else//删除失败返回-1{ERR_EXIT("shmctr");}

IPC_RMID是 shmctl第二个参数时->当引用计数为0即shmdt将所有附加进程都分离后，内核自动销毁该段。

4. 共享内存优缺点

优点

直接读写共享内存，没有数据拷贝  例如管道中拷贝到管道文件再拷贝出来的操作。资源占用就少。并且独立于进程存在，可以通过shmctl来显式删除

 缺点

附加到共享内存后进程可以自由读写(没设置SHM_RDONLY)，恶意进程可能破坏数据。

没有同步机制，容易导致数据不一致，由于数据更新不及时。可以通过命名管道的同步机制解决这一问题

 5. 源码

Shm.hpp

#pragma once
#include<iostream>
#include<sys/shm.h>
#include<sys/ipc.h>
#include<string>
#include<unistd.h>
const int gdefaultid=-1;
const int gsize=4096;
std::string pathname=".";
const int projid=0x66;
const int mode=0666;
#define CREATER "creater" 
#define USER "user"#define ERR_EXIT(m)  \
do \
{  \perror(m);  \exit(EXIT_FAILURE); \
}while(0)  \class Shm
{
private:void CreateHelper(int flg){printf("key: 0x%x\n",_k);_shmid=shmget(_k,_size,flg);if(_shmid<0){ERR_EXIT("shmid");}printf("shmid: %d\n",_shmid);        }void Creat()//创建共享内存{// std::cout<<"创建共享内存的是： "<<_usertype<<std::endl;CreateHelper(IPC_CREAT|IPC_EXCL|mode);//要给权限}void Get()//获取共享内存{CreateHelper(IPC_CREAT);}void Detach(){int n=shmdt(_start_mem);//将指针与共享内存分离if(n==0)//成功{printf("shmctl delete shm: %d success!\n",_shmid);}else{ERR_EXIT("shmdt");}}
public:Shm(const std::string& pathname,int projid,const std::string& usertype):_shmid(gdefaultid),_size(gsize),_start_mem(nullptr),_usertype(usertype){_k=ftok(pathname.c_str(),projid);if(_k<0){ERR_EXIT("ftok");}if(_usertype==CREATER) Creat();//如果是创建者else if(_usertype==USER) Get();//用户使用else{}Attach();}void Destroy(){if(_shmid==gdefaultid) return;//没初始化int n=shmctl(_shmid,IPC_RMID,nullptr);if(n==0)//删除成功返回0{Detach();//分离指针// printf("shmctl delete shm: %d success!\n",_shmid);}else//删除失败返回-1{ERR_EXIT("shmctr");}}void Attach()//{_start_mem=shmat(_shmid,nullptr,0);if((long long)_start_mem<0){std::cout<<"shmat 失败"<<std::endl;ERR_EXIT("shmat");}printf("Attach success\n");}void* VirtualAddr()//返回虚拟地址{printf("VirtualAddr %p\n",_start_mem);return _start_mem;}int Size(){return _size;}void Attr(){//System V 共享内存机制中用于描述共享内存段状态的核心数据结构//通过 shmctl() 系统调用进行读取或修改。struct shmid_ds ds;//结构体int n=shmctl(_shmid,IPC_STAT,&ds);printf("shm_segsz: %ld\n",ds.shm_segsz);printf("key: 0x%x\n",ds.shm_perm.__key);}~Shm(){if(_usertype==CREATER)//创建的负责删除Destroy();}
private:int _shmid;key_t _k;int _size;void* _start_mem;std::string _usertype;
};

 fifo.hpp

通过命名管道来同步

#pragma once
#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#define FIFO_FILE "fifo"
// #define path '.'class Fifo
{
public:Fifo(const std::string& path,const std::string& name){umask(0);_fifoname=path+'/'+name;int n=mkfifo(_fifoname.c_str(),0666);if(n<0){std::cerr<<"mkfifo error"<<std::endl;//失败}}~Fifo(){int n=unlink(_fifoname.c_str());//删除管道文件if(n==0){std::cout<<"remove fifo success"<<std::endl;}else{std::cout<<"remove fifo failed"<<std::endl;}}
private:std::string _fifoname;
};class FileOper
{
public:FileOper(const std::string& path,const std::string& name):_path(path),_name(name){_fifoname=_path+"/"+_name;}void OpenForRead(){_fd=open(_fifoname.c_str(),O_RDONLY);if(_fd<0){std::cerr<<"open fifo error"<<std::endl;return ;}}void OpenForWrite(){_fd=open(_fifoname.c_str(),O_WRONLY);if(_fd<0){std::cerr<<"open fido success"<<std::endl;return ;}}void Wakeup()//唤醒{char c;c='a';int n=write(_fd,&c,1);if(n<0)std::cerr<<"write error"<<std::endl;}bool Wait()//看是否等待成功{char c;int n=read(_fd,&c,1);if(n>0) return true;return false;}void Close(){if(_fd>0)close(_fd);}~FileOper(){}
private:std::string _path;std::string _name;std::string _fifoname;int _fd;
};

server.cpp

#include"Shm.hpp"
#include"fifo.hpp"
int main()
{    Shm shm(pathname,projid,CREATER);shm.Attr();char* mem=(char*)shm.VirtualAddr();umask(0);Fifo fifo(".","fifo");FileOper wait(".","fifo");wait.OpenForRead();//// sleep(8);while(true){if(wait.Wait())//可以读了{printf("%s\n",mem);// sleep(1);}elsebreak;}// sleep(10);wait.Close();return 0;
}

client.cpp

#include"Shm.hpp"
#include"fifo.hpp"
int main()
{umask(0);FileOper writefile(".","fifo");writefile.OpenForWrite();Shm shm(pathname,projid,USER);char* mem=(char*)shm.VirtualAddr();int cur=0;for(int i=0;i<26;i++){mem[cur++]='a'+i;// sleep(1);mem[cur++]='a'+i;// sleep(1);mem[cur]=0;//设置为0writefile.Wakeup();//唤醒sleep(2);}writefile.Close();return 0;
}

---

这篇就到这里啦(๑′ᴗ‵๑)Ｉ Lᵒᵛᵉᵧₒᵤ❤