System V共享内存

最新推荐文章于 2024-08-22 17:27:46 发布
最新推荐文章于 2024-08-22 17:27:46 发布
阅读量657 收藏 15
点赞数 23
分类专栏： linux 文章标签： 算法 linux c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suinnn/article/details/141069352
版权

5. System V共享内存

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据

5.1 原理, 让不同进程看到同一份资源, 通过进程地址空间映射

image-20240802133231472

申请内存的步骤

  1. 申请共享物理内存
  2. 挂接到进程地址空间

释放共享内存的步骤

  1. 让进程的地址空间和物理内存去关联
  2. 释放共享内存

5.2 共享内存函数

5.2.1 shmget函数

功能：
    用来创建共享内存
函数原型:
	int shmget(key_t key, size_t size, int shmflg);
参数:
    key:这个共享内存段名字
    size:共享内存大小
    shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
返回值：
	成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

shmflg常用的两个参数

  1. IPC_CREAT: 如果你申请的共享内存不存在,就创建, 存在, 就获取并返回
  2. IPC CREAT|IPC EXCL:如果你申请的共享内存不存在, 就创建, 存在, 就出错返回。这样能确保如果我们申请成
    功了一个共享内存，这个共享内存一定是一个新的!

key的话题

  1. key是一个数字，这个数字是几，不重要。关键在于它必须在内核中具有唯一性，能够让不同的进程进行唯一性标识
  2. 第一个进程可以通过key创建共享内存. 第二个之后的进程, 只要拿着同一个key就可以和第一个进程看到同一个共享内存了
  3. 对于一个已经创建好的共享内存, key在描述那个共享内存的数据结构中
  4. 第一次创建的时候，必须有一个key了。
  5. key类似绝对路径, 特点是唯一

5.2.2 ftok函数

功能:
	将路径名和项目标识符转换为System V IPC密钥
函数原型:
    key_t ftok(const char *pathname, int proj_id);
参数:
	pathname: 路径
    proj_id: 项目id
返回值:
    如果成功，则返回生成的key_t值。
    如果失败，返回-1,errno表示stat(2)系统调用的错误。
描述:
	ftok()函数使用给定路径名命名的文件的标识(必须引用一个现有的、可访问的文件)和proj_id的最低有效8位(必须是非零的)来生成一个密钥t类型的System V IPC密钥，适合与msgget(2)、senget(2)或shnget(2)一起使用。当使用proj_id的相同值时，对于命名相同文件的所有路径名，结果值是相同的。当(同时存在的)文件或项目id不同时，返回的值应该不同。
  • 问题:为什么不让系统直接生成一个key,而需要我们手动生成呢?

因为系统直接生成的key不容易传给另一个我们想要通信的进程, 所以需要用户约定同一个key

key_t GetKey()
{
    key_t k = ftok(PATH.c_str(), PROID);
    if(k == -1) {
        log(FATAL, "ftok error, %s", strerror(errno));
        exit(1);
    }
    log(INFO, "Creat key sucess, key is %d", k);
    return k;
}

int GetShareMem()
{
    int shmid = shmget(GetKey(), SIZE, IPC_CREAT | IPC_EXCL);
    if(shmid == -1) {
        log(FATAL, "shmid error, %s", strerror(errno));
        exit(2);
    }
    log(INFO, "Creat shmid sucess, shmid is %d", shmid);
    return shmid;
}

image-20240802223403860

  • 问题:这里的shmid和key的区别

key: 只在操作系统内标定唯一性
shimid: 只在你的进程内，用来表示资源的唯一性!

5.2.3 查看和删除当前系统的共享内存

ipcs -m

image-20240802223436123

共享内存的生命周期是随内核的
除非用户主动关闭, 或者内核重启, 否则共享内存会一直存在

ipcrm -m shmid用来删除当前系统的共享内存

5.2.3 设置权限

只需要在shmget();第三个参数 或 上权限的数字即可

int shmid = shmget(GetKey(), SIZE, IPC_CREAT | IPC_EXCL | 0666);

image-20240802224835843

5.2.4shmat函数

功能：将共享内存段连接到进程地址空间
原型:
	void *shmat(int shmid, const void *shmaddr, int shmflg);
参数:
    shmid: 共享内存标识
    shmaddr:指定连接的地址
    shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY, 也可以是0, 表示共享内存段将被附加到由shmat()函数返回的地址处
返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1

shmaddr为NULL，核心自动选择一个地址
shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。
公式：shmaddr - (shmaddr % SHMLBA)shmflg=SHM_RDONLY，表示连接操作用来只读共享内存

5.2.5shmdt函数

功能：将共享内存段与当前进程脱离
原型:
	int shmdt(const void *shmaddr);
参数:
	shmaddr: 由shmat所返回的指针
返回值：成功返回0；失败返回-1
注意：将共享内存段与当前进程脱离不等于删除共享内存段

5.2.6 shmctl函数

功能：用于控制共享内存
原型:
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数:
    shmid:由shmget返回的共享内存标识码
    cmd:将要采取的动作
    buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值：成功返回0；失败返回-1

cmd的几个取值

image-20240803110931234

5.2.7 一个保存着共享内存的模式状态和访问权限的数据结构

参数buf(5.2.6中的buf)是一个指向shmid结构体的指针，在<sys/shm.h>中定义如下:
struct shmid_ds {
    struct ipc_perm shm_perm;    /* Ownership and permissions */
    size_t          shm_segsz;   /* Size of segment (bytes) */
    time_t          shm_atime;   /* Last attach time */
    time_t          shm_dtime;   /* Last detach time */
    time_t          shm_ctime;   /* Last change time */
    pid_t           shm_cpid;    /* PID of creator */
    pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
    shmatt_t        shm_nattch;  /* No. of current attaches */
    ...
};

ipc_perm结构定义如下(突出显示的字段可以使用IPC_SET设置):
struct ipc_perm {
    key_t          __key;    /* Key supplied to shmget(2) */
    uid_t          **uid**;      /* Effective UID of owner */
    gid_t          **gid**;      /* Effective GID of owner */
    uid_t          cuid;     /* Effective UID of creator */
    gid_t          cgid;     /* Effective GID of creator */
    unsigned short **mode**;     /* Permissions + SHM_DEST and
                                           SHM_LOCKED flags */
    unsigned short __seq;    /* Sequence number */
};

5.2.8当前的代码

// common.hpp
#ifndef __COMMON__H__
#define __COMMON__H__

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

using namespace std;
const string PATH = "/home/lyf";
const int PROID = 0x1234;
// 共享内存的大小建议是4096的整数倍
// 当我们将SIZE改为4097时,OS实际给我们的是4096*2的大小, 但多出来的那4095byte我们并不能使用
// 这就造成了浪费
const int SIZE = 4096;
Log log;

key_t GetKey()
{
    key_t k = ftok(PATH.c_str(), PROID);
    if(k == -1) {
        log(FATAL, "ftok error, %s", strerror(errno));
        exit(1);
    }
    log(INFO, "Creat key sucess, key is 0x%x", k);
    return k;
}

int ShareMemHelper(int flag)
{
    int shmid = shmget(GetKey(), SIZE, flag);
    if(shmid == -1) {
        log(FATAL, "shmid error, %s", strerror(errno));
        exit(2);
    }
    log(INFO, "Creat shmid sucess, shmid is %d", shmid);
    return shmid;
}

// 创建共享内存
int CreatShareMem()
{
    return ShareMemHelper(IPC_CREAT | IPC_EXCL | 0666);
}

// 获取共享内存的shimid
int GetShareMem()
{
    return ShareMemHelper(IPC_CREAT);
}
#endif

// processA.cc
#include "common.hpp"
int main()
{
    sleep(3);
    // 申请共享物理内存
    int shmid = CreatShareMem();
    sleep(3);
    // 挂接到进程地址空间
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    log(INFO, "Attach shm done, shmaddr is 0x%x", shmaddr);
    sleep(3);
    // 让进程的地址空间和物理内存去关联
    shmdt(shmaddr);
    log(INFO, "Detatch shm done, shmaddr is 0x%x", shmaddr);
    sleep(3);
    // 释放共享内存
    shmctl(shmid, IPC_RMID, nullptr);
    log(INFO, "Free shm done, shmaddr is 0x%x", shmaddr);
    sleep(3);
    log(INFO, "Process quit");
    return 0;
}

image-20240803111806772

image-20240803111834793

5.2.9 再加一个程序

// processB.cc
#include "common.hpp"

int main()
{
    sleep(3);
    // 获取共享物理内存
    int shmid = GetShareMem();
    sleep(3);
    // 挂接到进程地址空间
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    log(INFO, "Attach shm done, shmaddr is 0x%x", shmaddr);
    sleep(3);
    // 让进程的地址空间和物理内存去关联
    shmdt(shmaddr);
    log(INFO, "Detatch shm done, shmaddr is 0x%x", shmaddr);
    sleep(3);
    log(INFO, "Process quit");
    return 0;
}

image-20240803112916065

image-20240803112948282

5.2.10进程间通信

我们上面做的工作, 已经可以让不同的进程看到同一份资源了, 下面进行通信

// processA.cc
#include "common.hpp"

int main()
{
    int shmid = CreatShareMem();
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    // 一旦有人把数据写入到共享内存，其实我们立马能看到了
    // 不需要经过系统调用，直接就能看到数据了!
    // IPC code, 让A进程读
    while(true) {
        cout << "Process say@ " << shmaddr;   // 直接访问共享内存
        sleep(1);
    }
    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, nullptr);
    return 0;
}

// processB.cc
#include "common.hpp"

int main()
{
    int shmid = GetShareMem();
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    // 一旦有了共享内存，挂接到自己的地址空间中，你直接把他当成你的内存空间来用即可!
    // 不需要调用系统调用
    // IPC code, 让B进程写
    while(true) {
        // 直接访问共享内存
        // cout << "Please enter@ ";   
        // fgets(shmaddr, SIZE, stdin);
        // 通过一个buffer来访问
        char buffer[1024];
        cout << "Please enter@ ";   
        fgets(buffer, sizeof(buffer), stdin);
        // strlen+1, 让读取的时候读到\0
        memcpy(shmaddr, buffer, strlen(buffer)+1);
    }
    shmdt(shmaddr);
    return 0;
}

image-20240803123458734

可以看到, 进程A在一直读取

5.3共享内存的特点

  1. 共享内存没有同步互斥之类的保护机制

  2. 共享内存是所有的进程间通信中，速度最快的

​ 因为拷贝少, 对比管道, 管道当我们像管道写数据, 需要write(), 数据从用户级缓冲区拷贝到内核级缓冲区, 从管道中读数据, 需要read(), 数据再次拷贝, 从内核级缓冲区拷贝到用户级缓冲区

  1. 共享内存内部的数据，由用户自己维护

5.4添加管道

修改一下5.2.10中的代码, 不让processA一直刷屏, 引入了之前写的命名管道的代码

// common.hpp
#ifndef __COMMON__H__
#define __COMMON__H__

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

using namespace std;
const string PATH = "/home/lyf";
const int PROID = 0x1234;
// 共享内存的大小建议是4096的整数倍
// 当我们将SIZE改为4097时,OS实际给我们的是4096*2的大小, 但多出来的那4095byte我们并不能使用
// 这就造成了浪费
const int SIZE = 4096;
Log log;

key_t GetKey()
{
    key_t k = ftok(PATH.c_str(), PROID);
    if(k == -1) {
        log(FATAL, "ftok error, %s", strerror(errno));
        exit(1);
    }
    log(INFO, "Creat key sucess, key is 0x%x", k);
    return k;
}

int ShareMemHelper(int flag)
{
    int shmid = shmget(GetKey(), SIZE, flag);
    if(shmid == -1) {
        log(FATAL, "shmid error, %s", strerror(errno));
        exit(2);
    }
    log(INFO, "Creat or Get shmid sucess, shmid is %d", shmid);
    return shmid;
}

// 创建共享内存
int CreatShareMem()
{
    return ShareMemHelper(IPC_CREAT | IPC_EXCL | 0666);
}

// 获取共享内存的shimid
int GetShareMem()
{
    return ShareMemHelper(IPC_CREAT);
}

#define FIFO_FILE "./myfifo"
#define MODE 0666

const int N = 1024;

enum {
    FIFO_CREAT_ERR = 1,
    FIFO_DEL_ERR,
    FIFO_OPEN_ERR,
    FIFO_READ_ERR
};

// 用于处理server.cc部分代码的初始化和析构处理
struct Init
{
    Init()
    {
        // 创建信道
        int n = mkfifo(FIFO_FILE, MODE);
        if (n == -1) {
            perror("mkfifo");
            exit(FIFO_CREAT_ERR);
        }
    }
    ~Init()
    {
        // 删除信道
        int m = unlink(FIFO_FILE);
        if (m == -1) {
            perror("unlink");
            exit(FIFO_DEL_ERR);
        }
    }
};
#endif

// processA.cc
#include "common.hpp"

int main()
{
    Init init;
    int shmid = CreatShareMem();
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    // 一旦有人把数据写入到共享内存，其实我们立马能看到了
    // 不需要经过系统调用，直接就能看到数据了!
    // IPC code, 让A进程读
    struct shmid_ds shmds;
    // 打开信道
    int fd = open(FIFO_FILE, O_RDONLY);      // 等待写入方打开之后, 自己才会打开文件, 向后执行, open 阻塞了！
    if(fd == -1) {
        log(FATAL, "open error, %s", strerror(errno));
        exit(FIFO_OPEN_ERR);
    }
    while(true) {
        char c;
        ssize_t s = read(fd, &c, 1);
        if(s == 0)  break;
        else if(s == -1)    break;
        cout << "Process say@ " << shmaddr;   // 直接访问共享内存
        // shmctl(shmid, IPC_STAT, &shmds);
        // cout << "No. of current attaches" << shmds.shm_nattch<<endl;
        // cout << "key is" << shmds.shm_perm.__key<<endl;
        // sleep(1);
    }
    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, nullptr);
    close(fd);
    return 0;
}

// processB.cc
#include "common.hpp"

int main()
{
    int shmid = GetShareMem();
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    // 一旦有了共享内存，挂接到自己的地址空间中，你直接把他当成你的内存空间来用即可!
    // 不需要调用系统调用
    // IPC code, 让B进程写
    // 打开信道
    int fd = open(FIFO_FILE, O_WRONLY);
    if(fd == -1) {
        log(FATAL, "open error, %s", strerror(errno));
        exit(FIFO_OPEN_ERR);
    }
    while(true) {
        // 直接访问共享内存
        cout << "Please enter@ ";   
        fgets(shmaddr, SIZE, stdin);
        write(fd, "c", 1);      // 通知另一个进程
        // 通过一个buffer来访问
        // char buffer[1024];
        // cout << "Please enter@ ";   
        // fgets(buffer, sizeof(buffer), stdin);
        // // strlen+1, 让读取的时候读到\0
        // memcpy(shmaddr, buffer, strlen(buffer)+1);
    }
    shmdt(shmaddr);
    return 0;
}

image-20240803152741403

冰红茶兑滴水
关注
  • 23
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Posix与System V共享内存区
weixin_50866517的博客
09-29 931
要使用 POSIX 共享内存对象需要完成下列任务：使用shm_open()函数打开一个与指定的名字对应的对象。shm_open()函数与 open()系统调用类似，它会创建一个新共享对象或打开一个既有对象。作为函数结果，shm_open()会返回一个引用该对象的文件描述符。将上一步中获得的文件描述符传入mmap()调用并在其flags参数中指定MAP_SHARED。这将共享内存对象映射进进程的虚拟地址空间。与mmap()一样，一旦映射了对象之后就能够关闭该文件描述符而不会影响到这个映射。
system V——共享内存
h1091068389的博客
05-21 1272
共享内存system V共享内存共享内存函数接口shmgetkey手动查看/释放共享内存key和shmid区别shmctl挂接shmdt system V SystemV标准的进程间通信方式是在操作系统层面专门为进程间通信设计的一个方案。进程间通信的本质就是让不同的进程能够看到同一份资源。 常见的system V结构的通信方式有如下几种： 共享内存 消息队列 信号量 这篇博客主要介绍基于共享内存的进程间通信方式。 共享内存 共享内存是通过某种调用，在内存中创建一份内存空间，然后通过函数调用，让需要参与进程通
Linux通信：基于System V共享内存方式实现进程间通信
Zhenyu_Coder的博客
07-12 1868
一、基于共享内存通信方式原理 二、共享内存优缺点 2.1 共享内存优缺点 2.2 基于文件通信 vs 共享内存通信 三、相关函数调用接口 2.1 创建共享内存（shmget） 2.1.1 key 2.1.2 size 2.1.3 shmflg 2.1.4 返回值 2.2 共享内存段挂接到进程地址空间（shmat） 2.3 将共享内存段与当前进程脱离（shmdt） 2.4 用于控制共享内存（删除）（shmctl） 四、基于System V共享内存实现进程间通信
【Linux】system V 共享内存
努力进大厂的小码娄
01-30 1754
共享内存，是映射到物理内存中。shmget,shmat,shmdt shmctl函数的介绍。共享内存是可以提供大容量的，不支持同步机制，是效率速度最快的通信方式。
Linux 下共享内存方式 ：System V共享内存、共享文件映射(mmap)、POSIX共享内存对比...
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
12-14 1248
在Linux下，共享内存是一种重要的进程间通信机制，主要包括System V共享内存、共享文件映射（mmap）和POSIX共享内存这三种技术。下面是一个Markdown表格，用于比较这三种技术的优劣势：
Linux-System V共享内存
m0_51415606的博客
04-21 1135
共享内存是所有IPC中最快的一种。它之所以快是因为共享内存一旦映射到进程的地址空间，进程之间数据的传递就不需要涉及内核了。发送信息的一方，通过系统调用（write或msgsnd）将信息从用户层拷贝到内核层，由内核暂存这部分信息。提取信息的一方，通过系统调用（read或msgrcv）将信息从内核层提取到应用层。建立共享内存之后，内核完全不参与进程间的通信，这种说法严格来讲并不是正确的。因为当进程使用共享内存时，可能会发生缺页，引发缺页中断，这种情况下，内核还是会参与进来的。
【Linux】System V 共享内存
宁清的博客
01-30 1318
"System V 共享内存" 是一种在类Unix操作系统中实现的共享内存机制，得名于AT&T的UNIX System V操作系统，其中引入了这种共享内存的概念。System V共享内存是System V IPC（Inter-Process Communication，进程间通信）机制的一部分，与其他System V IPC机制，如消息队列和信号量一起，提供了进程间通信的方式。
进程间通信，SystemV共享内存
qq_55439426的博客
11-03 977
无
【Linux】进程间通信3——system V共享内存
2301_80224556的博客
06-18 1378
管道通信本质是基于文件的，也就是说操作系统并没有为此做过多的设计工作，但是不管怎么样，它们的本质都是一样的，都是在想尽办法让不同的进程看到同一份由操作系统提供的资源。其中，，虽然system V信号量和通信好像没有直接关系，但属于通信范畴。
【Linux】System V 共享内存、消息队列、信号量
阿润菜菜的博客
04-22 1396
带你深入理解共享内存 消息队列 信号量
解决Linux system v 共享内存问题
09-14
以下是关于Linux System V共享内存的详细知识点： 1. ** shmget 函数**： `shmget`是创建或获取共享内存段的关键函数。其三个参数分别是： - `key_t key`：用于唯一标识共享内存段。可以使用`ftok`函数生成一个键...
php进程(线程)通信基础之System V共享内存简单实例分析
10-16
主要介绍了php进程(线程)通信基础之System V共享内存,结合简单实例形式分析了PHP System V共享内存原理、相关函数与基本使用技巧,需要的朋友可以参考下
libandroid-shmem:使用Ashmem在Android上进行System V共享内存仿真
05-03
libandroid-shmem 在使用ashmem在Android上进行System V共享内存（shmget，shmat，shmdt和shmctl）仿真。 它创建的共享内存段将在创建过程销毁它们或死时自动销毁，这与System V共享内存行为不同。 基于先前工作。...
System V共享内存与信号量综合应用之生产者与消费者问题解决
05-27
System V IPC（Interprocess Communication）是Unix/Linux系统中实现进程间通信的一种方式，它提供了三种主要机制：信号量（Semaphore）、消息队列（Message Queue）和共享内存（Shared Memory）。在这个问题中，...
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 371
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 229
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
C语言——函数递归
2406_83392683的博客
08-18 391
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 631
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 369
哈希表解决存在重复元素二问题
POSIX 共享内存或 System V 共享内存, cpp先进先出通知队列
05-19
POSIX 共享内存和 System V 共享内存都是用于进程间通信的机制，它们都允许多个进程访问同一块共享内存。不同之处在于它们的接口和实现方式不同。 POSIX 共享内存是在 POSIX 标准中定义的，通过 mmap 系统调用映射一个共享内存区域到进程的地址空间中。进程可以通过对该区域的读写来进行进程间通信。POSIX 共享内存使用简单，但是只能在支持 POSIX 标准的系统上使用。 System V 共享内存是一种更古老的机制，它使用特殊的系统调用来创建和管理共享内存。System V 共享内存在不同的系统上的实现方式可能略有不同，但是基本原理是相同的。使用 System V 共享内存需要了解其详细的接口和实现方式。 至于 cpp 先进先出通知队列，这是一种基于共享内存的通信机制，用于在多个进程之间传递数据。它的实现方式可以使用 POSIX 共享内存或 System V 共享内存。它的基本思想是利用一个共享内存缓冲区和两个指针来实现数据的传递和同步。具体实现可以参考相关的资料和代码示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值