欢迎光临
我们一直在努力
        找回密码
当前位置：171主机测评 > 服务器技术 > 正文

【Linux】进程间通信——System V共享内存

2026-02-02 分类：服务器技术 阅读(83) 评论(0)

🔥 个人主页：大耳朵土土垚

🔥 所属专栏：Linux系统编程

这里将会不定期更新有关Linux的内容，欢迎大家点赞，收藏，评论🥳🥳🎉🎉🎉

文章目录

  • 前言
  • 1. 基本原理
  • 2. 数据结构
  • 3. 创建与使用
    • ✨进程间通信实例
  • 4. 共享内存特点
  • 5. 结语

前言

  System V是一种在Linux系统中用于进程间通信（IPC）的机制。它提供了几种不同的通信方式，包括共享内存、消息队列和信号量。以下是关于Linux进程间通信System V共享内存的详细解释：

1. 基本原理

  System V共享内存是IPC（进程间通信）机制的一部分，它允许两个或多个进程共享一段物理内存。这段内存可以被所有参与的进程读取和写入。这种方式通常比较高效，因为进程可以直接对内存进行读写操作，而不需要通过内核进行数据传输。如下图所示： 在这里插入图片描述

2. 数据结构

  System V共享内存可以在内存中创建多个，所以操作系统需要借助一种数据结构来管理它。System V共享内存使用struct shmid_ds结构体来描述共享内存的状态和属性。该结构体包括共享内存的键值key用来唯一标识共享内存，还包括了共享内存的权限、大小、创建时间、最后访问时间等信息。

注意键值key是由用户定义的标识符，不是系统生成的，这是因为进程间需要通过key来确定和使用共享内存，如果是由系统创建的，那么其他进程就无法得知该共享内存的key，从而无法使用。如果是用户自己定义的，那么用户想让哪个进程使用都可以。

3. 创建与使用

  创建System V共享内存段的主要函数有shmget、shmat、shmdt和shmctl。

  • int shmget(key_t key, size_t size, int shmflg);

    • 该函数用于创建一个新的共享内存段或者获取一个已有的共享内存段。
    • 参数key是一个用户定义的标识符，通常通过ftok()函数生成。

    因为用户不确定哪些key值已经被使用了，哪些没被使用，所以操作系统提供了一个函数，可以帮助用户生成唯一的标识符。

    • key_t ftok(const char *pathname, int proj_id);

    ftok函数将给定的文件路径名（pathname）和项目ID（proj_id）根据算法转换为一个键值（key_t），用于创建或访问System V IPC资源（如消息队列、共享内存、信号量等）。这样不同进程间只需知道文件路径和项目ID就可以确定共享内存的标识符key了。

    • 参数size指定了共享内存段的大小（以字节为单位）。
    • 参数shmflg我们主要学习两种：IPC_CREAT和IPC_EXCL。

    IPC_CREAT和IPC_EXCL都是宏，IPC_CREAT表示如果通过key值标识的共享内存不存在就创建；存在就获取该共享内存并返回它。

    IPC_EXCL单独使用无意义，通常是和IPC_CREAT搭配使用，IPC_CREAT|IPC_EXCL，使用逻辑运算符或连接：表示如果通过key值标识的共享内存不存在就创建；存在就出错返回。

    • shmget返回值是一个共享内存标识符，如果出错则返回-1。

    注意这个标识符不是key，而是给用户用的一个标识共享内存的标识符。

    • 例如，创建一个共享内存：

    #include<iostream>
    #include<string>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    const std::string gpath = "/home/tutu/ProcessCommunicate/sharemem";
    const int ProcessId = 0;
    const size_t gsize = 4096;
    int main()
    {
    key_t key = ftok(gpath.c_str(),ProcessId);//获取唯一key值
    int shmid = ::shmget(key,gsize,IPC_CREAT|IPC_EXCL);
    if(shmid < 0)
    std::cout<<"共享内存创建失败…"<<std::endl;
    std::cout<<"共享内存key值："<<key<<", "<<"shmid:"<<shmid<<std::endl;
    return 0;
    }

    结果如下：

    在这里插入图片描述

    我们还可以通过命令行命令来管理共享内存：

    • ipcs -m:用来查看系统的共享内存： 在这里插入图片描述

    虽然Server进程已经运行完了，但是共享内存还是存在；这是因为只要创建了共享内存没被删除，那么共享内存的生命周期就随内核！

    • ipcrm -m shmid:用来删除共享内存： 在这里插入图片描述
  • int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    • 对共享内存段执行特定的控制操作。
    • 参数shmid是由shmget()返回的共享内存标识符。
    • 参数cmd指定要执行的操作，例如IPC_RMID移除共享内存段，IPC_STAT获取共享内存段的状态等。
    • 参数buf是一个指向shmid_ds结构的指针，用来存储或修改共享内存段的信息。
    • 成功时返回0，出错时返回-1。

    例如，使用shmctl删除一个共享内存：

    #include<iostream>
    #include<string>
    #include<unistd.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    const std::string gpath = "/home/tutu/ProcessCommunicate/sharemem";
    const int ProcessId = 0;
    const size_t gsize = 4096;
    int main()
    {
    //1.创建共享内存
    key_t key = ftok(gpath.c_str(),ProcessId);
    int shmid = ::shmget(key,gsize,IPC_CREAT|IPC_EXCL);
    if(shmid < 0)
    std::cout<<"共享内存创建失败…"<<std::endl;
    std::cout<<"共享内存key值："<<key<<", "<<"shmid:"<<shmid<<std::endl;

    sleep(5);

    //2. 删除共享内存
    if(shmctl(shmid,IPC_RMID,nullptr)==0)
    std::cout<<"删除共享内存成功…"<<std::endl;

    return 0;
    }

    结果如下： 在这里插入图片描述

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

    • 将共享内存段连接到调用进程的地址空间。

    共享内存创建后必须挂接到进程中，获取到虚拟地址后才可以通过地址进行写入和读取

    • 参数shmid是由shmget()返回的共享内存标识符。
    • 参数shmaddr指定了共享内存段附加的位置，通常设置为NULL让系统选择适当的地址。
    • 参数shmflg可以包含标志如SHM_RND和SHM_RDONLY，这里我们设置为0即可。
    • 成功时返回指向共享内存段的指针，出错时返回(void *) -1。

    • 例如，将创建的共享内存挂接到进程中：

    #include<iostream>
    #include<string>
    #include<unistd.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    const std::string gpath = "/home/tutu/ProcessCommunicate/sharemem";
    const int ProcessId = 0;
    const size_t gsize = 4096;
    int main()
    {
    //1.创建共享内存
    key_t key = ftok(gpath.c_str(),ProcessId);
    int shmid = ::shmget(key,gsize,IPC_CREAT|IPC_EXCL);
    if(shmid < 0)
    std::cout<<"共享内存创建失败…"<<std::endl;
    std::cout<<"共享内存key值："<<key<<", "<<"shmid:"<<shmid<<std::endl;

    sleep(5);

    //2. 挂接共享内存
    void* ret = shmat(shmid,nullptr,0);
    if((long long)ret == –1)
    std::cout<<"共享内存挂接失败…"<<std::endl;

    //3. 删除共享内存
    if(shmctl(shmid,IPC_RMID,nullptr)==0)
    std::cout<<"删除共享内存成功…"<<std::endl;
    else
    std::cout<<"共享内存挂接成功…"<<std::endl;
    return 0;
    }

    结果如下： 在这里插入图片描述

    发现共享内存挂接失败，这是因为我们在创建共享内存时没有设置权限，导致我们没有权限挂接，所以在创建共享内存时必须带上权限：shmget(key,gsize,IPC_CREAT|IPC_EXCL|0600);，与文件权限一致0600表示拥有者可读可写，所以正确代码如下：

    #include<iostream>
    #include<string>
    #include<unistd.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    const std::string gpath = "/home/tutu/ProcessCommunicate/sharemem";
    const int ProcessId = 0;
    const size_t gsize = 4096;
    int main()
    {
    //1.创建共享内存
    key_t key = ftok(gpath.c_str(),ProcessId);
    int shmid = ::shmget(key,gsize,IPC_CREAT|IPC_EXCL|0600);
    if(shmid < 0)
    std::cout<<"共享内存创建失败…"<<std::endl;
    std::cout<<"共享内存key值："<<key<<", "<<"shmid:"<<shmid<<std::endl;

    sleep(5);

    //2. 挂接共享内存
    void* ret = shmat(shmid,nullptr,0);
    if((long long)ret == –1)
    std::cout<<"共享内存挂接失败…"<<std::endl;
    else
    std::cout<<"共享内存挂接成功…"<<std::endl;

    //3. 删除共享内存
    if(shmctl(shmid,IPC_RMID,nullptr)==0)
    std::cout<<"删除共享内存成功…"<<std::endl;

    return 0;
    }

    在这里插入图片描述 使用ipcs -m可以看到(注意这里没有删除共享内存才可以看到)： 在这里插入图片描述

  • int shmdt(const void *shmaddr);
    • 断开与共享内存段的连接。
    • 参数shmaddr是shmat()返回的指针。
    • 成功时返回0，出错时返回-1。

    • #include<iostream>
    #include<string>
    #include<unistd.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    const std::string gpath = "/home/tutu/ProcessCommunicate/sharemem";
    const int ProcessId = 0;
    const size_t gsize = 4096;
    int main()
    {
    //1.创建共享内存
    key_t key = ftok(gpath.c_str(),ProcessId);
    int shmid = ::shmget(key,gsize,IPC_CREAT|IPC_EXCL|0600);
    if(shmid < 0)
    std::cout<<"共享内存创建失败…"<<std::endl;
    std::cout<<"共享内存key值："<<key<<", "<<"shmid:"<<shmid<<std::endl;

    sleep(5);

    //2. 挂接共享内存
    void* ret = shmat(shmid,nullptr,0);
    if((long long)ret == –1)
    std::cout<<"共享内存挂接失败…"<<std::endl;
    else
    std::cout<<"共享内存挂接成功…"<<std::endl;

    //3.断联共享内存
    if(shmdt(ret) == 0)
    std::cout<<"断开共享内存成功…"<<std::endl;

    //4. 删除共享内存
    if(shmctl(shmid,IPC_RMID,nullptr)==0)
    std::cout<<"删除共享内存成功…"<<std::endl;

    return 0;
    }

    结果如下： 在这里插入图片描述

    创建、挂接、断联以及删除共享内存原理如下： 在这里插入图片描述

    ✨进程间通信实例

    • 基于以上4个函数，我们就可以封装一个ShareMem类来进行进程间通信：

    #pragma once

    #include <iostream>
    #include <string>
    #include <cstdio>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdalign.h>
    #include <unistd.h>

    const std::string gpath = "/home/tutu/ProcessCommunicate/sharemem";
    int gprojId = 0x6666;
    // 操作系统，申请空间，是按照块为单位的：4KB，1KB， 2KB， 4MB
    int gshmsize = 4096;
    mode_t gmode = 0600;

    class ShareMem
    {
    private:
    void CreateShmHelper(int flag)
    {
    _key = ::ftok(gpath.c_str(), gprojId);
    if (_key < 0)
    {
    std::cout << "创建共享内存时ftok出错…" << std::endl;
    return;
    }
    _shmid = ::shmget(_key, gshmsize, flag); // 不存在返回-1
    if (_shmid < 0)
    {
    std::cout << "创建共享内存时shmget出错…" << std::endl;
    return;
    }
    }

    public:
    ShareMem() : _shmid(–1), _key(0),_pshm(nullptr)
    {
    }
    // 创建共享内存
    void CreateShareMem()
    {
    if (_shmid < 0)
    CreateShmHelper(IPC_CREAT | IPC_EXCL | gmode);
    }

    //获取共享内存
    void GetShareMem()
    {
    if(_shmid < 0)
    CreateShmHelper(IPC_CREAT);
    }

    //挂接共享内存
    void AttachShareMem()
    {
    if(_shmid>0)
    _pshm = ::shmat(_shmid,nullptr,0);
    }

    //去关联共享内存
    void DetachShareMem()
    {
    if(_pshm)
    ::shmdt(_pshm);
    }
    //删除共享内存
    void DeleteShareMem()
    {
    if(_shmid > 0)
    ::shmctl(_shmid, IPC_RMID, nullptr);
    }

    //获取共享内存地址
    void* GetShareMemAddr()
    {
    return _pshm;
    }
    private:
    int _shmid;
    key_t _key;
    void* _pshm;
    };

    ShareMem shm;

    • 创建共享内存并写入内容：

    因为共享内存的指针是void*，可以是任意类型，也就是说共享内存实际上是通过指针进行读取和写入的，所以这里我们将它强制转化为字符指针进行写入读取。

    int main()
    {
    //1.创建共享内存
    shm.CreateShareMem();

    //2.挂接共享内存
    shm.AttachShareMem();

    //3. 获取共享内存地址
    char *str = (char*)shm.GetShareMemAddr();//强转为字符指针

    //4. 写入数据到共享内存
    int n = 0;
    while(n <= 10)
    {
    str[n] = n+'0';
    n++;
    sleep(2);
    }

    //5.断开共享内存
    shm.DetachShareMem();

    //6.删除共享内存
    shm.DeleteShareMem();

    return 0;
    }

    • 获取共享内存并读取内容：

    int main()
    {
    //1.获取共享内存
    shm.GetShareMem();

    //2.挂接共享内存
    shm.AttachShareMem();

    //3. 获取共享内存地址
    char *str = (char *)shm.GetShareMemAddr();//强转为字符指针

    //4. 读取共享内存内容
    int n = 10;
    while(n—)
    {
    printf("%s\\n",str);
    sleep(2);
    }

    //5.断开共享内存
    shm.DetachShareMem();

    //6.删除另一个进程删即可

    return 0;
    }

    每隔2s读取一次内容并打印

    同时运行两个进程，结果如下： 在这里插入图片描述

    4. 共享内存特点

  • 通信速度最快

    • 这是因为相较于管道通信需要通过文件缓冲区操作而言，共享内存只需通过指针操作即可

  • 不同进程间共享内存块，但是没有任何保护机制

    • 所以共享内存需要由用户自己完成保护，可以通过命名管道、加锁等操作。

    5. 结语

      System V共享内存是一种高效的进程间通信（IPC）机制，它允许多个进程共享一块物理内存区域，从而避免了数据的复制，显著提高了数据传输速率。以上就是有关进程间通信中System V共享内存的所有内容啦~ 完结撒花 ~🥳🎉🎉

    赞(0)
    未经允许不得转载：171主机测评 » 【Linux】进程间通信——System V共享内存
    分享到： 更多 (0)
    标签：

    相关推荐

    评论 抢沙发

    取消

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址

    热门标签

    #人工智能(59928)#python(20270)#开发语言(16981)#java(15583)#运维(15452)#linux(15031)#大数据(14670)#服务器(13131)#算法(11834)#前端(10997)#网络(9440)#ai(9053)#数据库(8974)#c++(8215)#课程设计(6849)#学习(6827)#机器学习(6744)#区块链(5937)#OpenClaw(5396)#后端(5207)#spring boot(5043)#深度学习(4979)#c语言(4390)#毕业设计(4316)#数据结构(4215)#安全(4124)#docker(3947)#架构(3906)#javascript(3821)#大模型(3686)

    热门文章

    最新文章

    归档

    分类