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

发布于:2024-07-11 ⋅ 阅读:(23) ⋅ 点赞:(0)

在这里插入图片描述

👦个人主页:Weraphael
✍🏻作者简介:目前正在学习c++和算法
✈️专栏:Linux
🐋 希望大家多多支持,咱一起进步!😁
如果文章有啥瑕疵,希望大佬指点一二
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注😍


一、共享内存的工作原理

请添加图片描述

Linux操作系统除了要为进程创建结构体对象task_struct(表示进程的数据结构,包含了进程的所有属性,如进程标识符PID);除此之外,操作系统还会为每个进程创建进程地址空间结构体对象mm_struct(存储了进程的地址空间信息,包括堆、栈等)。该进程要如何找到自己的进程地址空间呢?因此task_struct结构体还会有该进程对应的mm_struct结构体指针字段,可以通过task_struct对象找到对应的进程地址空间。

另外,操作系统还需为每个进程创建页表Linux操作系统系统会通过分页机制来管理虚拟地址和物理地址之间的映射关系,用于将虚拟地址映射到物理地址。当程序访问虚拟地址时,操作系统会根据页表将虚拟地址转换为物理地址。

而进程间通信的本质是:让不同的进程看到同一份资源。因此,共享内存的原理就是:因为进程具有独立性,无法自己提供资源给对方,因此操作系统会在物理内存中开辟一块内存(“共享内存”由操作系统提供),再通过页表映射到两个不同进程的虚拟地址空间中的共享区,此时两个独立的进程看到同一块空间,那么就可以进行通信了。(整个过程类似于动态库的加载)

除此之外,因为共享内存是由程序员向操作系统申请的,当然还需要正确地释放共享内存资源,以避免内存泄漏和资源占用。释放共享内存的过程包括两个主要步骤:

  • 解除所有与要释放的共享内存有关系的进程(去关联)
  • 最后释放共享内存,通常由最后一个使用该共享内存段的进程来执行(释放共享内存)

因此,System V共享内存通信的整个过程总结如下:

  • 创建共享内存段

  • 进程挂接共享内存

  • 通信

  • 解除共享内存挂接

二、系统调用接口

共享内存的创建、进程间建立映射和释放都是由操作系统完成的。对应的操作系统也要为用户提供访问和管理共享内存的接口,允许用户在程序中使用共享内存来实现进程间通信。

2.1 shmget函数 — 创建共享内存

shmget 函数是一个用于创建共享内存或者访问已存在共享内存段,通常用于在进程之间共享数据而无需通过文件系统。它的函数原型如下:

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

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

参数说明:

  • key:可以唯一标识一个共享内存段(内核层使用)。这个值是多少并不重要,关键在于它必须具有唯一性,能够让不同的进程看到同一个共享内存(两个进程传入相同的key值即看到同一块内存)。就这样说吧,第一个进程通过key值创建共享内存,后面的进程要用看到同一个共享内存通信,只需拿同一个key值即可!注意:这个key值在struct shmid_ds对象中。那么接下来只有最后一个问题:如何获取设置key?一般使用 ftok 函数生成唯一key值(常用)。(查看函数用法:点击跳转

  • size指定要创建的共享内存段的大小,以字节为单位。如果创建新的共享内存段,建议分配4096的整数倍(如果你创建的大小是4097,实际上操作系统分配的大小是4096 * 2)。如果只是获取一个已存在的共享内存段的标识符,这个参数可以设置为0来表示忽略。

  • shmflg:这是一个标志参数,用于指定操作模式和权限。可以用操作符'|'进行组合使用。它可以是以下几个标志的组合:

    • IPC_CREAT这个选项单独使用的话,如果申请的共享内存不存在,则创建一个新的共享内存;如果存在,获取已存在的共享内存
    • IPC_EXCL: 一般配合 IPC_CREAT 一起使用(不单独使用)。他主要是检测共享内存是否存在,如果存在,则出错返回;如果不存在就创建。确保申请的共享内存一定是新的。
    • 权限标志:以与文件权限类似的方式指定共享内存段的访问权限(例如 0666 表示所有用户可读写)。
    • 但在获取已存在的共享内存时,可以设置为 0
  • 返回值:

    • 成功时返回共享内存段的标识符shmid。(操作系统内部分配的,提供给用户层使用,类似于文件描述符fd

    • 失败时返回 -1,并设置 errno 以指示错误原因。

  • 返回值常见错误errno如下:

    • EACCES:对于给定的键值没有足够的权限。

    • EEXIST: 设置了 IPC_CREAT | IPC_EXCL,但具有给定键值的共享内存段已经存在。

    • EINVAL: 请求的大小无效,或者给定的键值无效。

    • ENOENT: 没有设置 IPC_CREAT,而且具有给定键值的共享内存段不存在。

    • ENOMEM: 没有足够的内存来满足请求。

ftok函数是专门用于生成唯一键值,通常用于进程间通信的共享内存、信号量和消息队列。它通过将文件路径(路径本身就具有唯一性)项目标识符ID 结合起来生成一个唯一的键值。其函数原型如下:

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

key_t ftok(const char *pathname, int proj_id);
  • pathname: 指向一个现有文件的路径。这个文件可以是任何文件,但在实际应用中,通常选择一个固定存在且不会被删除的文件。

  • proj_id: 项目标识符,一个用户指定的整数值。该值一般用于扩展唯一性,如果冲突该次参数就行。

  • 返回值:

    • 成功时返回生成的键值 (key_t 类型)。可以用于后续的函数调用(如shmget()等)。

    • 失败时返回 -1,并设置 errno 以指示错误原因。

常见的 errno 值包括:

  • EACCES: 文件不可访问。
  • ENOENT: 文件不存在。
  • ENAMETOOLONG: 路径名过长。

代码样例:

resource.hpp中封装创建共享内存段的接口,来供其他进程使用。

#pragma once

#include <iostream>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string>
#include <cstring>
#include "log.hpp"

using namespace std;

const string pathname = "/home/wj"; // ftok函数的第一个参数
int proj_id = 'A';                  // ftok函数的第二个参数
log l;                              // 日志对象

key_t Getkey()
{
    key_t key = ftok(pathname.c_str(), proj_id);
    if (key == -1)
    {
        l.logmessage(Fatal, "ftok error: %s", strerror(errno));
        exit(1);
    }
    l.logmessage(Info, "ftok success, key is: 0x%x", key);
    return key;
}

int GetShareMem()
{
    key_t key = Getkey();
    int shmid = shmget(key, 4096, IPC_CREAT | IPC_EXCL);
    if (shmid == -1)
    {
        l.logmessage(Fatal, "create share memory error: %s", strerror(errno));
    }
    l.logmessage(Info, "create share memory success: %d", shmid);
    return shmid;
}

我们先使用一个进程processA.cc来测试一下

#include "resource.hpp"

int main()
{
    int shmid = GetShareMem();

    l.logmessage(Debug, "process quit...");
    return 0;
}

结果如下:

请添加图片描述

2.2 补充:key值和shmid的区别

不同的进程在选择共享内存通信时,是通过key值来保证共享内存的唯一性,那这里就存在一个问题:shmget函数也会返回一个值,我们把这个值称为共享内存段标识符shmid,而往后要对共享内存进行操作(如附加、分离、删除等)的时候,通常使用的是shmid来进行操作。为什么要创建两种共享内存的标识呢?直接使用一个来进行标识不就够了嘛?

那么这里我就可以举一个生活中的例子来进行解释:我们中国有14+亿的人口,每个人出生之后就会拥有一个独一无二(唯一)的身份证号,通过这个身份证号我们就可以标识一个人,那为什么还要给每个人取一个名字呢?直接使用身份证号来代替名字不就可以了吗?之所以这么做是因为使用名字可以更加方便的社交,在短范围内能够更快的确定一个人,如果使用身份证号的话就会导致标识和管理的时候比较臃肿。

那么这里也是同样的道理,key就相当于身份证号,shmid相当于姓名。站在用户角度,使用key值来标定共享内存太难了太复杂了,所以我们使用shmid来标识共享内存这样可以更加的方便和容易;而操作系统它不嫌麻烦他为了更加严谨的标识共享内存就必须得使用更加复杂的key值来进行标定,就好比政府机构在处理具体某个人的事情时,都会拿身份证号来标定某个人,因为身份证号更加的复杂、更加的准确、权威性更高。因此key是给内核层使用的。

key值在哪里存储的呢?我们说操作系统中存在多个共享内存所以要进行先描述在组织,那么描述共享内存的shm结构体中就存在一个字段专门用来记录共享内存的key值,所以key值会通过系统调用shmget设置进共享内存的属性中的用来表示共享内存在内核中的唯一性。

总之,shmid相当于文件系统的文件描述符fd,而key就相当于文件系统的inode编号,inode编号是用来给操作系统看的,fd是用来给我们操作者使用的,操作系统之所以这么做是为了方便标识符的解藕,用户层和操作系统层使用不同的东西来标识内存,这样用户层和操作系统层就不会发生相互的干扰,也就是一个层面出现了问题不会影响另外的一个层面,那么这就是key(内核层使用)和shmid(用户层使用)的区别。

2.3 shmctl函数 — 释放

请添加图片描述

如上,当我再次启动进程processA的时候,我们发现使用shmget函数创建共享内存失败了,原因是文件存在(共享内存段存在)。通过分析我们知道:我使用IPC_CREATIPC_EXCL选项保证进程每次申请的共享内存一定是新的,而在第一次运行完进程processA,我们的代码内并没有手动释放共享内存段,因此导致报错!

Linux中,如果想查看操作系统管理的共享内存段,我们可以使用以下命令:

ipcs -m

请添加图片描述

共享内存的生命周期是随内核的(操作系统重启,共享内存通常才会被释放)!因为共享内存是由用户向操作系统申请的,如果不主动关闭,共享内存会一直存在。另外,如果程序频繁地分配共享内存而不释放,系统的可用内存资源会逐渐减少,可能导致系统性能下降或者其它进程受到影响(内存泄漏)。

有两种方法可以释放共享内存段:

  • 使用以下命令来指定释放共享内存段
ipcrm -m <shmid>

请添加图片描述

  • 使用系统调用接口shmctl函数

shmctl 函数用于对共享内存进行控制操作,例如获取共享内存信息、设置共享内存权限、销毁共享内存等。它的原型如下:

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

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

参数说明:

  • shmid:共享内存标识符shmid

  • cmd:控制命令,可以是下列之一:

    • IPC_STAT:获取共享内存的状态信息,并将其存储在 buf 结构体中。
    • IPC_SET:设置共享内存的状态信息,使用 buf 结构体中提供的新值。
    • IPC_RMID:删除共享内存段。
  • buf:指向描述共享内存的结构体shmid_ds的指针,用于存储或传递共享内存的状态信息。如果是删除共享内存段,此参数可以设置为nullptr

  • 返回值:成功返回0,失败返回-1

【代码样例】

#include "resource.hpp"

int main()
{
    // 创建共享内存段
    int shmid = GetShareMem();
    l.logmessage(Debug, "create shm done");

    // 销毁共享内存段
    int res = shmctl(shmid, IPC_RMID, nullptr);
    if (res == -1)
    {
        l.logmessage(Error, "share Memory destroy failed, shmid is %d", shmid);
        exit(Error);
    }
    l.logmessage(Debug, "share Memory destroy success, shmid is %d", shmid);

    l.logmessage(Debug, "process quit...");
    return 0;
}

【程序结果】

请添加图片描述

2.4 shmat函数 — 进程挂接共享内存

shmat函数的基本作用是将一个共享内存段映射到调用进程的地址空间的共享区,从而使得进程可以直接访问共享内存中的数据。

函数基本原型如下:

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
  • shmid:共享内存的标识符shmid

  • shmaddr:指定共享内存段映射到进程地址空间的起始地址,通常设为 nullptr,让系统自动选择合适的地址。

  • shmflg:附加标志,通常设为 0

  • 返回值:成功返回指向共享内存的起始地址的指针;失败返回nullptr

  • 代码写法有点类似于malloc函数

  • 注意:进程退出后,会自动解除挂接。

为了更好观察进程挂接共享内存的个数,在销毁共享内存段之前休眠10

#include "resource.hpp"

int main()
{
    // 1. 创建共享内存段
    int shmid = GetShareMem();
    l.logmessage(Debug, "create shm done");

    // 2. 挂接共享内存段
    char *shmaddress = (char *)shmat(shmid, nullptr, 0);
    if (shmaddress == nullptr)
    {
        l.logmessage(Error, "processA attach failed, shmid is %d", shmid);
    }
    l.logmessage(Debug, "processA attach success, shmid is %d", shmid);

    // 休眠10s
    sleep(10);

    // 3. 销毁共享内存段
    int res = shmctl(shmid, IPC_RMID, nullptr);
    if (res == -1)
    {
        l.logmessage(Error, "share Memory destroy failed, shmid is %d", shmid);
        exit(Error);
    }
    l.logmessage(Debug, "share Memory destroy success, shmid is %d", shmid);

    l.logmessage(Debug, "process quit...");
    return 0;
}

【程序结果】

请添加图片描述

2.5 shmdt函数 — 手动解除进程和共享内存挂接

shmdt 函数用于将共享内存从当前进程的地址空间中分离,即取消共享内存的映射。这个函数的原型如下:

#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);
  • shmaddr 参数是一个指向共享内存段起始地址的指针,通常是shmat函数的返回值。
  • 返回值:成功返回0,失败返回-1

代码演示略 ~

三、使用以上接口让两个进程通信

一般而言,只要有一方进程创建了共享内存段,另一方进程直接获取其共享内存段标识符shmid后,即可进行通信。

  • resource.hpp主要是封装获取共享内存段接口,确保两个进程使用的是同一块共享内存。
#pragma once

#include <iostream>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string>
#include <cstdlib>
#include <cstring>
#include "log.hpp"

using namespace std;

const string pathname = "/home/wj"; // ftok函数的第一个参数
int proj_id = 'A';                  // ftok函数的第二个参数
log l;                              // 日志对象

key_t Getkey()
{
    key_t key = ftok(pathname.c_str(), proj_id);
    if (key == -1)
    {
        l.logmessage(Fatal, "ftok error: %s", strerror(errno));
        exit(1);
    }
    l.logmessage(Info, "ftok success, key is: 0x%x", key);
    return key;
}

int GetShareMem()
{
    key_t key = Getkey();
    int shmid = shmget(key, 4096, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid == -1)
    {
        l.logmessage(Fatal, "create share memory error: %s", strerror(errno));
    }
    l.logmessage(Info, "create share memory success, shmid is %d", shmid);
    return shmid;
}

int GetShm()
{
    // 大小:获取一个已存在的共享内存段的标识符,这个参数可以设置为0来表示忽略
    // 第三个参数:获取已存在的共享内存时,可以设置为 0
    return shmget(Getkey(), 0, 0);
}
  • processA.cc主要是负责读取共享内存段的数据。注意:此进程要先运行起来。
#include "resource.hpp"

int main()
{
    // 1. 创建共享内存段
    int shmid = GetShareMem();

    // 2. 挂接共享内存段
    char *shmaddress = (char *)shmat(shmid, nullptr, 0);

    // 3. 通信
    while (true)
    {
        // 假设processA进程作为客户端,负责读取
        cout << "client say@ " << shmaddress << endl;
        if (strcmp(shmaddress, "quit\n") == 0)
        {
            break;
        }
        sleep(1);
    }

    // 4. 取消挂接
    shmdt(shmaddress);

    // 5. 销毁共享内存段
    int res = shmctl(shmid, IPC_RMID, nullptr);

    return 0;
}
  • processB主要是向共享内存段写入数据。当写入quit时整个通信过程结束。
#include "resource.hpp"

int main()
{
    // 1. 获取shmid
    int shmid = GetShm();

    // 2. 挂接共享内存
    char *shmaddress = (char *)shmat(shmid, nullptr, 0);

    // 3. 通信
    while (true)
    {
        // processB进程作为服务端,负责写
        cout << "请输入:";
        char *context = fgets(shmaddress, 4096, stdin);
        if (context != nullptr && strcmp(shmaddress, "quit\n") == 0)
        {
            break;
        }
    }
    // 4. 取消挂接
    shmdt(shmaddress);

    return 0;
}
  • 程序结果

在这里插入图片描述

四、共享内存的特性

  • 共享内存没有同步和互斥之类的保护机制。即读写双方可以同时访问共享内存,这会导致数据不一致问题,这个问题的解决方案将在下方会介绍到。

  • 共享内存是所有的进程间通信中,速度最快的!原因在于它减少数据拷贝。在使用共享内存时,多个进程可以直接访问同一块物理内存,而不需要将数据从一个进程的地址空间复制到另一个进程的地址空间。这避免了数据在内存之间的复制,从而减少了通信的开销和延迟。

  • 共享内存内部的数据由用户自己维护(读完要自己清空)。

  • 共享内存的生命周期是随内核的,用户不主动删除,共享内存会一直存在(除非内核重启或用户释放)

  • 共享内存的大小一般建议是4096的整数倍,内存管理的一页大小为4096字节(4KB)。若申请4097,则系统会分配4096 * 2,但用户还是只能使用4097的空间,会存在4095字节空间的浪费。

五、共享内存的属性

而我们知道,因为系统中不止一对进程在进行通信,可能会存在多个,那么操作系统就要在物理内存上开辟多个共享内存,那么操作系统就必须对这些区域进行管理,这又得搬出管理的六字真言:先描述,再组织。在Unix/Linux中,描述共享内存段的信息通常通过 struct shmid_ds 结构体来表示:

struct shmid_ds 
{
    /*
    这是一个 struct ipc_perm 结构体,用于描述共享内存的操作权限
    struct ipc_perm 包含了共享内存段的拥有者、组和访问权限等信息。
    */
    struct ipc_perm shm_perm; 
    // shm_segsz表示共享内存段的大小,单位是字节
    int shm_segsz; 
    // shm_atime表示最后一次附加该共享内存段的时间。
    __kernel_time_t shm_atime; 
    // shm_dtime表示最后一次分离该共享内存段的时间。
    __kernel_time_t shm_dtime; 
    // 表示最后一次更改该共享内存段的时间。
    __kernel_time_t shm_ctime;
    // shm_cpid表示关联共享内存的进程标识符PID
    __kernel_ipc_pid_t shm_cpid;
    // shm_lpid表示最后一个操作该共享内存段的进程的 PID
    __kernel_ipc_pid_t shm_lpid; 
    // shm_nattch表示当前使用到该共享内存段的进程数
    unsigned short shm_nattch; 
    // ...
};
//  struct ipc_perm 结构体
struct ipc_perm 
{
       // key 用于标识共享内存段。不同的进程可以通过这个key来访问同一个共享内存段。
       key_t  __key;    
       // uid 拥有者(owner)的有效用户ID(UID),即对共享内存段有读写权限的用户的UID。
       uid_t  uid;      
       // gid 这是拥有者的有效组ID(GID),即对共享内存段有读写权限的用户所在的组的GID。
       gid_t  gid;     
       // cuid 这是创建者(creator)的有效用户ID(UID),即创建共享内存段的进程的UID。 
       uid_t  cuid;    
       // cgid 这是创建者的有效组ID(GID),即创建共享内存段的进程所在的组的GID。 
       gid_t  cgid;  
       // mode 这个字段包含了权限和一些特定标志,如使用IPC_CREAT来创建IPC对象。
       unsigned short mode;     
       // __seq 这个字段是序列号,用于维护IPC对象的序列。                                 
       unsigned short __seq;    
};

最后再通过诸如链表、顺序表等数据结构将这些结构体对象管理起来。因此,往后我们对共享内存的管理,只需转化为对某种数据结构的增删查改。

我们可以使用shmctl函数来获取属性信息(具体用法查看往上翻)

int main()
{
    //  创建共享内存段
    int shmid = GetShareMem();

    // 挂接共享内存段
    char *shmaddress = (char *)shmat(shmid, nullptr, 0);

    // 获取共享内存的属性
    struct shmid_ds shmds;
    shmctl(shmid, IPC_STAT, &shmds);
    cout << "共享内存的大小:" << shmds.shm_segsz << endl;
    cout << "共享内存的连接数:" << shmds.shm_nattch << endl;
    printf("共享内存的key值:0x%x\n", shmds.shm_perm.__key);

    // 取消挂接
    shmdt(shmaddress);

    return 0;
}

【程序结果】

请添加图片描述

六、解决共享内存没有同步和互斥保护机制问题

共享内存的特点是 无读写规则限制,进程即可读也可写,容易造成冲突,因此我们可以对其加以限制,所使用的工具正是命名管道。

逻辑思路是这样的:当共享内存的写方向共享内存段写完数据后,使用命名管道向读方发送一条通知,说明可以向共享内存读取数据了。

  • resource.hpp增加了创建命名管道的类
#pragma once

#include <iostream>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string>
#include <sys/stat.h>
#include <cstdlib>
#include <cstring>
#include "log.hpp"

using namespace std;

const string pathname = "/home/wj"; // ftok函数的第一个参数
int proj_id = 'A';                  // ftok函数的第二个参数
log l;                              // 日志对象

key_t Getkey()
{
    key_t key = ftok(pathname.c_str(), proj_id);
    if (key == -1)
    {
        l.logmessage(Fatal, "ftok error: %s", strerror(errno));
        exit(1);
    }
    l.logmessage(Info, "ftok success, key is: 0x%x", key);
    return key;
}

int GetShareMem()
{
    key_t key = Getkey();
    int shmid = shmget(key, 4096, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid == -1)
    {
        l.logmessage(Fatal, "create share memory error: %s", strerror(errno));
    }
    l.logmessage(Info, "create share memory success, shmid is %d", shmid);
    return shmid;
}

int GetShm()
{
    // 大小:获取一个已存在的共享内存段的标识符,这个参数可以设置为0来表示忽略
    // 第三个参数:获取已存在的共享内存时,可以设置为 0
    return shmget(Getkey(), 0, 0);
}

// ================== 命名管道 ==============================
enum
{
    // 规定错误码从1开始递增
    MKFIFO_FAIL = 1, // 创建匿名管道失败
    UNLINK_FAIL,     // 删除匿名管道失败
    OPEN_FAIL        // 打开文件失败
};

class Init
{
public:
    Init()
    {
        // 创建管道
        int n = mkfifo("./myfifo", 0664);
        if (n == -1)
        {
            perror("mkfifo");
            exit(MKFIFO_FAIL);
        }
    }
    ~Init()
    {
        int m = unlink("./myfifo");
        if (m == -1)
        {
            perror("unlink");
            exit(UNLINK_FAIL);
        }
    }
};
  • processB.cc是写方,当写完后就向管道写入一个字符作为通知。
int main()
{
    // 1. 获取shmid
    int shmid = GetShm();

    // 2. 挂接共享内存
    char *shmaddress = (char *)shmat(shmid, nullptr, 0);

    // 打开命名管道
    int fd = open("./myfifo", O_WRONLY);
    if (fd == -1)
    {
        exit(OPEN_FAIL);
    }

    // 3. 通信
    while (true)
    {
        // processB进程作为服务端,负责写
        cout << "请输入:";
        char *context = fgets(shmaddress, 4096, stdin);
        // 写完之后,通知对方来读取。
        write(fd, "c", 1);
        if (context != nullptr && strcmp(shmaddress, "quit\n") == 0)
        {
            break;
        }
    }
    // 4. 取消挂接
    shmdt(shmaddress);
    close(fd);

    return 0;
}
  • processA.cc是读方,在向共享内存段读取之前,先判断管道是否有“通知”,有则可以读取。
int main()
{
    // 创建管道
    Init init;

    // 1. 创建共享内存段
    int shmid = GetShareMem();

    // 2. 挂接共享内存段
    char *shmaddress = (char *)shmat(shmid, nullptr, 0);

    // 打开命名管道
    int fd = open("./myfifo", O_RDONLY);
    if (fd == -1)
    {
        exit(OPEN_FAIL);
    }

    // 3. 通信
    while (true)
    {
        // 假设processA进程作为客户端,负责读取
        // 在读取之前先去管道看看是否有通知
        char c;
        ssize_t s = read(fd, &c, 1);
        // s == 0 说明没读到,那就继续读取
        if (s == 0)
        {
            continue;
        }
        // s == -1说明读取发生错误,那就退出
        if (s == -1)
        {
            break;
        }

        cout << "client say@ " << shmaddress << endl;
        if (strcmp(shmaddress, "quit\n") == 0)
        {
            break;
        }
        sleep(1);
    }

    // 4. 取消挂接
    shmdt(shmaddress);

    // 5. 销毁共享内存段
    int res = shmctl(shmid, IPC_RMID, nullptr);
    close(fd);

    return 0;
}
  • 程序结果

在这里插入图片描述

七、本篇博客源代码

Gitee链接:点击跳转