Linux--进程间的通信-共享内存-Toy模板网

这篇具有很好参考价值的文章主要介绍了Linux--进程间的通信-共享内存。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前文：
Linux–进程间的通信-匿名管道
Linux–进程间的通信–进程池
Linux–进程间的通信-命名管道

共享内存

对于两个进程，通过在内存开辟一块空间（操作系统开辟的），进程的虚拟地址通过页表映射到对应的共享内存空间中，进而实现通信；

特点和作用：

高效性： 共享内存是一种高效的进程间通信方式，因为它允许多个进程直接访问同一块内存，而无需进行复制或数据传输。
快速通信： 由于共享内存直接映射到进程的地址空间，因此读写速度快，适用于对通信速度有较高要求的场景。
灵活性： 共享内存提供了一种灵活的通信方式，允许多个进程在需要时访问共享数据，而无需通过中间介质进行通信。
数据共享： 多个进程可以通过共享内存实现数据共享，从而实现对数据的共同读写和处理。

模拟实现

Linux--进程间的通信-共享内存,Linux,linux,数据库,运维

代码

Comm.hpp:包含共享内存的创建，销毁，挂接进程等。

#pragma once

#include<stdio.h>
#include<iostream>
#include<string>
#include<cerrno>
#include<cstring>
#include<cstdlib>
#include<sys/ipc.h>
#include<sys/types.h>
#include<sys/shm.h>
using namespace std;


const char* pathname="/home/ubuntu/Learning/Pipe";
const int proj_id=0x66;

//在内核中，共享内存的基本单位是4kb，我们申请的大小相当于是n*4kb
const int DefaultSize=4096;

//将key值转换为16进制的；
string ToHEX(key_t k)
{
    char buffer[1024];
    snprintf(buffer,sizeof(buffer),"0x%x",k);
    return buffer;
}

//获取键值
key_t GetShmKeyorDie()
{
    key_t k=ftok(pathname,proj_id);
    if(k<0)
    {
        //当返回值为-1时，错误表示stat(2)系统调用错误
        cerr << "ftok error, errno : " << errno << ", error string: " << strerror(errno) << endl;
        exit(1);
    }
    return k;
}

//创建共享内存，只在该函数内调用
int CreateShmOrDie(key_t key,int size,int flag)
{
    int shmid = shmget(key,size,flag);
    if(shmid<0)
    {
        std::cerr << "shmget error, errno : " << errno << ", error string: " << strerror(errno) << std::endl;
        exit(2);
    }
    return shmid;

}

//调用时的创建共享内存
int CreateShm(key_t key,int size)
{
    //如果已经存在了，那么会报错；
    return CreateShmOrDie(key,size,IPC_CREAT|IPC_EXCL|0666);
}
//调用时的获取
int GetShm(key_t key,int size)
{
    return CreateShmOrDie(key,size,IPC_CREAT);
}

//删除共享内存
void DeleteShm(int shmid)
{
    int n=shmctl(shmid,IPC_RMID,nullptr);
    if(n<0)
    {
        cerr<<"shmctl error"<<endl;
    }
    else
    {
        cout<<"shmctl delete shm success, shmid: "<<shmid<<endl;
    }
}

//查看共享内存的状态
void ShmDebug(int shmid)
{
    struct shmid_ds shmds;
    int n=shmctl(shmid ,IPC_STAT,&shmds);
    if(n<0)
    {
        std::cerr << "shmctl error" << std::endl;
        return;
    }
    std::cout << "shmds.shm_segsz: " << shmds.shm_segsz << std::endl;
    std::cout << "shmds.shm_nattch:" << shmds.shm_nattch << std::endl;
    std::cout << "shmds.shm_ctime:" << shmds.shm_ctime << std::endl;
    std::cout << "shmds.shm_perm.__key:" << ToHEX(shmds.shm_perm.__key) << std::endl;
}

void* ShmAttach(int shmid)
{
    void* addr = shmat(shmid,nullptr,0);
    //第二个参数设置nullptr，表示让系统选择合适的地址进行连接
    if((long long int)addr==-1)
    {
        cerr<<"shmat error"<<endl;
        return nullptr;
    }
    return addr;
}

void ShmDetach(void* addr)
{
    int n=shmdt(addr);
    if(n<0)
    {
        cerr<<"shmdt error"<<endl;
    }
}

fifo.hpp:利用管道来实现对共享内存实现同步机制。

#include<iostream>
#include<string>
#include<cstring>
#include<cerrno>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<assert.h>
using namespace std;

#define Mode 0666
#define Path "./fifo"

class fifo
{
public:
    fifo(const string & path=Path)
    :_path(path)
    {
        umask(0);
        int n=mkfifo(_path.c_str(),Mode);
        if(n==0)
        {
            cout<< "mkfifo success" << endl;
        }
        else
        {
            cerr << "mkfifo failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        }
    }
    ~fifo()
    {
        int n=unlink(_path.c_str());
        if (n == 0)
        {
            cout << "remove fifo file " << _path << " success" << endl;
        }
        else
        {
            cerr << "remove failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        }
    }
private:
    string _path; //文件路径
};

class Sync
{
public:
    Sync()
    :_rfd(-1),
    _wfd(-1)
    {}
    void OpenReadOrDie()
    {
        _rfd=open(Path,O_RDONLY);
        if(_rfd<0)
            exit(1);
    }
    void OpenWriteDie()
    {
        _wfd=open(Path,O_WRONLY);
        if(_wfd<0)
            exit(1);
    }
    bool Wait()
    {
        bool ret=true;
        uint32_t c=0;
        ssize_t n=read(_rfd,&c,sizeof(uint32_t));
        if(n==sizeof(uint32_t))
        {
            cout<<"server wakeup ,begin read shm..."<<endl;
        }
        else if(n==0)
        {
            ret=false;
        }
        else
        {
            return false;
        }
        return ret;
    }
    void Wakeup()
    {
        uint32_t c=0;
        ssize_t n=write(_wfd,&c,sizeof(c));
        assert(n==sizeof(uint32_t));

        cout<<"wakeup server..."<<endl;
    }
    ~Sync() {}
private:
    int _wfd;
    int _rfd;
};

ShmServer.cc

#include "Comm.hpp"
#include "fifo.hpp"
#include<unistd.h>
int main()
{
    
    //1.获取key
    key_t key = GetShmKeyorDie();
    std::cout << "key: " << ToHEX(key) << std::endl;
    // sleep(2);
    
    //2.创建共享内存
    int shmid = CreateShm(key, DefaultSize);
    std::cout << "shmid: " << shmid << std::endl;
     sleep(2);
  

    //4.将共享内存与进程挂接
    char* addr=(char*)ShmAttach(shmid);
    cout<<"Attach shm success, addr: "<<ToHEX((uint64_t)addr)<<endl;
   
    //0.先引入管道
    fifo ff;
    Sync syn;
    syn.OpenReadOrDie();

   //进行通信
     while(1)
     {
        if(!syn.Wait())break;
        cout<<"shm content: "<<addr<<endl;
     }

    ShmDetach(addr);
    std::cout << "Detach shm success, addr: " << ToHEX((uint64_t)addr) << std::endl;
     
     
    //3.删除共享内存
    DeleteShm(shmid);
    return 0;
}

ShmClient.cc

#include"Comm.hpp"
#include "fifo.hpp"
#include<unistd.h>
int main()
{
    key_t key = GetShmKeyorDie();
    std::cout << "key: " << ToHEX(key) << std::endl;
    // sleep(2);

    int shmid = GetShm(key, DefaultSize);
    std::cout << "shmid: " << shmid << std::endl;
    
    
    char* addr=(char*)ShmAttach(shmid);
    cout<<"Attach shm success, addr: "<<ToHEX((uint64_t)addr)<<endl;
    
    
    //通信
    memset(addr,0,DefaultSize);
    Sync syn;
    syn.OpenWriteDie();
    for(char c ='A';c<='Z';c++)
    {
        addr[c-'A']=c;
        sleep(1);
        syn.Wakeup();
    }

    ShmDetach(addr);
    std::cout << "Detach shm success, addr: " << ToHEX((uint64_t)addr) << std::endl;
    
    return 0;
}