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

最新推荐文章于 2024-04-13 17:23:13 发布
最新推荐文章于 2024-04-13 17:23:13 发布
阅读量855 收藏 16
点赞数 24
分类专栏： Linux 文章标签： linux java 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74215144/article/details/136457329
版权

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

目录

作者：爱写代码的刚子

时间：2024.3.3

前言：本篇博客将介绍system V共享内存，进程通信的本质就是让不同的进程先看到同一份资源。

system V共享内存

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

共享内存示意图

共享内存让不同进程看到同一份资源的方式就是，通过一种接口在物理内存当中申请一块内存空间，然后通过此接口将这块内存空间分别与各个进程各自的页表之间建立映射，再在虚拟地址空间当中开辟空间并将虚拟地址填充到各自页表的对应位置，使得虚拟地址和物理地址之间建立起对应关系，至此这些进程便看到了同一份物理内存，这块物理内存就叫做共享内存。

img

注意：
这里所说的开辟物理空间、建立映射等操作都是调用系统接口完成的，也就是说这些动作都由操作系统来完成。所以操作系统需要提供具有如下功能的接口：

  • 创建共享内存 —— 删除共享内存（OS内部帮我们做）
  • 关联共享内存 —— 去关联共享内存（进程做，实际也是OS做）

这个操作不能由进程来执行，而由操作系统来执行，因为进程是需求方，操作系统是执行方。

（操作系统需要管理共享内存，先描述（多大，谁申请的，有多少进程关联，使用了多少，引用计数），再组织！），所以存在struct结构体，对共享内存的管理变成了对数据结构的增删查改。

共享内存的数据结构

在系统当中可能会有大量的进程在进行通信，因此系统当中就可能存在大量的共享内存，那么操作系统必然要对其进行管理，所以共享内存除了在内存当中真正开辟空间之外，系统一定还要为共享内存维护相关的内核数据结构。共享内存的数据结构如下：

struct shmid_ds {
	struct ipc_perm shm_perm; /* operation perms */
	int shm_segsz; /* size of segment (bytes) */
	__kernel_time_t shm_atime; /* last attach time */
	__kernel_time_t shm_dtime; /* last detach time */
	__kernel_time_t shm_ctime; /* last change time */
	__kernel_ipc_pid_t shm_cpid; /* pid of creator */
	__kernel_ipc_pid_t shm_lpid; /* pid of last operator */
	unsigned short shm_nattch; /* no. of current attaches */
	unsigned short shm_unused; /* compatibility */
	void* shm_unused2; /* ditto - used by DIPC */
	void* shm_unused3; /* unused */
};

共享内存函数

  • shmget函数

在这里插入图片描述

  • 功能：用来创建共享内存

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

  • 参数:

    • key：表示待创建共享内存在系统中的唯一标识
    • size：表示带创建共享内存的大小（单位是字节）（建议设置为页[4KB]的整数倍）
    • shmflg：表示创建共享内存的方式，由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的

    在这里插入图片描述

IPC_CREAT（单独）：如果你申请的共享内存不存在，就创建，存在，就获取并返回

IPC_CREAT | IPC_EXCL ：如果你申请的共享内存不存在，就创建，存在，就出错返回。这样确保我们成功申请的这个共享内存一定是新的！

IPC_EXCL不单独使用

  • 返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1；

【问题】：如何保证让不同的进程看见同一个共享内存呢？/ 如何知道这个共享内存存在还是不存在？

  1. 第一个参数key（共享内存标识符）可以保证，key是几并不重要。关键在于它必须在内核中具有唯一性，能够让不同的进程进行唯一性标识。
  2. 第一个进程可以通过key创建共享内存，第二个之后的进程，只要拿着同一个key就可以和第一个进程看到同一个共享内存了。
  3. 对于一个已经创建好的共享内存，key在哪？key在共享内存的描述对象中！
  4. 第一次创建的时候，必须要有key。
  5. key——类似——路径——唯一
  • ftok函数

在这里插入图片描述

ftok函数并没有在内核里做任何事情，只是一套算法，将pathname和proj_id进行数值计算，形成冲突概率比较小的key即可！理论上pathname和proj_id可以由用户指定（用户约定的）。

举一个例子：

common.hpp:

#ifndef __COMM_HPP__
#define __COMM_HPP__

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include "log.hpp"
using namespace std;


const string pathname = "/home/Harvey/ceshi/共享内存";
const int proj_id = 0x5555;
const int size = 4096;
Log mylog;

key_t GetKey()
{
    key_t k = ftok(pathname.c_str(),proj_id);
    if(k<0)
    {
        mylog(Fatal,"ftok error:%s",strerror(errno));
        exit(1);
    }
    mylog(Info,"ftok success!key is %d",k);
    return k;
}

int GetShareMem()
{
    key_t k =GetKey();
    int shmid = shmget(k,size,IPC_CREAT | IPC_EXCL);
    if(shmid<0)
    {
        mylog(Fatal,"create share memory error:%s",strerror(errno));
        exit(2);
    }
    mylog(Info,"create share memory success,shmid:%d",shmid);
    return shmid;
}

#endif

log.hpp:

#pragma once

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <stdarg.h>

#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4

#define Screen 1
#define Onefile 2
#define Classfile 3

#define SIZE 1024

#define LogFile "log.txt"


class Log{
public:
    Log():printMethod(Screen),path("./log/")
    {}
    

    ~Log()
    {

    }
    void Enable(int method)
    {
        printMethod = method;
    }

    std::string levelToString(int level)
    {
        switch(level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "None";
        }
    }

    void printLog(int level,const std::string &logtxt)
    {
        switch(printMethod)
        {
        case Screen:
            std::cout<<logtxt<<std::endl;
            break;
        case Onefile:
            printOneFile(LogFile,logtxt);
            break;
        case Classfile:
            printClassFile(level,logtxt);
            break;
        default:
            break;
        }
    }
    void printOneFile(const std::string &logname,const std::string &logtxt)
    {
        std::string _logname = path+logname;
        int fd = open(_logname.c_str(),O_WRONLY | O_CREAT | O_APPEND, 0666);
        if(fd<0)return;
        write(fd,logtxt.c_str(),logtxt.size());
        close(fd);

    }

    void printClassFile(int level,const std::string &logtxt)
    {
        std::string filename =LogFile;
        //为文件名添加后缀
        filename+=".";
        filename+=levelToString(level);
        printOneFile(filename,logtxt);
    }

    void operator()(int level,const char *format,...)
    {
        time_t t = time(nullptr);
        struct tm *ctime =localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer,sizeof(leftbuffer),"[%s][%d-%d-%d %d:%d:%d]",levelToString(level).c_str(),
        ctime->tm_year + 1900,ctime->tm_mon+1,ctime->tm_mday,
        ctime->tm_hour,ctime->tm_min,ctime->tm_sec);

        //提取可变参数
        va_list s;
        va_start(s,format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer,sizeof(rightbuffer),format,s);
        va_end(s);

        //格式：默认部分——自定义部分
        char logtxt[SIZE*2];
        snprintf(logtxt,sizeof(logtxt),"%s %s\n",leftbuffer,rightbuffer);

        printLog(level,logtxt);


    }

private:
    int printMethod;
    std::string path;
};

makefile:

.PHONY:all
all:processa processb
processa:processa.cc
	g++ -o $@ $^ -g -std=c++11
processb:processb.cc
	g++ -o $@ $^ -g -std=c++11

.PHONY:clean
clean:
	rm -f processa processb

processa.cc:

#include "common.hpp"
using namespace std;
extern Log mylog;
int main()
{
    int shmid= GetShareMem();
    mylog(Debug,"shmid:%d",shmid);

    sleep(20);
    return 0;
}
  • 运行一下processa：

在这里插入图片描述

  • key vs shmid：

key用于操作系统内标定唯一性

shmid只在自己的进程内，用来标识资源的唯一性

  • 再运行一下processa：
    在这里插入图片描述

我们发现了报错，进程退出了，但是资源还在。

因为ipc资源是操作系统申请的，由操作系统进行管理。

  • ipcs -m查看所有的IPC资源(1.共享内存2.信号量3.消息队列)

在这里插入图片描述

共享内存的生命周期是随内核的！用户不主动关闭，共享内存会一直存在。除非内核重启，或者用户释放

  • ipcrm -m +shmid使用shmid释放共享内存，为什么不用key，因为key是在内核态的，shmid是在用户层的。

在这里插入图片描述

在这里插入图片描述

【问题】：如何设置共享内存的权限？

  • **int shmid = shmget(k,size,IPC_CREAT | IPC_EXCL | 0666);**将选项带上权限即可

在这里插入图片描述

再次注意！！共享内存的大小一般建议是4096字节（4kb）的整数倍。如果创建4097字节，实际上操作系统给出的是4096*2的大小

将共享内存挂接到对应的进程

  • shmat函数

在这里插入图片描述

  • char shmaddr = (char)shmat(shmid,nullptr,0);**将共享内存进行挂接

将共享内存取消挂接

  • shmdt函数

在这里插入图片描述

  • shmdt(shmaddr);

小知识，为什么释放共享内存时只需要传入起始地址？因为这个块空间还存了一些这块空间的属性（我们叫做cookie）

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

在这里插入图片描述

释放共享内存

  • shmctl函数

在这里插入图片描述

  • **shmctl(shmid,IPC_RMID,nullptr);**销毁共享内存

Common.hpp:

#ifndef __COMM_HPP__
#define __COMM_HPP__

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include "log.hpp"
using namespace std;


const string pathname = "/home/Harvey/ceshi/共享内存";
const int proj_id = 0x5555;
const int size = 4096;
Log mylog;

key_t GetKey()
{
    key_t k = ftok(pathname.c_str(),proj_id);
    if(k<0)
    {
        mylog(Fatal,"ftok error:%s",strerror(errno));
        exit(1);
    }
    mylog(Info,"ftok success!key is 0x%x",k);
    return k;
}

int GetShareMemHelper(int flag)
{
    key_t k =GetKey();
    int shmid = shmget(k,size,flag);
    if(shmid<0)
    {
        mylog(Fatal,"create share memory error:%s",strerror(errno));
        exit(2);
    }
    mylog(Info,"create share memory success,shmid:%d",shmid);
    return shmid;
}

int CreateShareMem()
{
    return GetShareMemHelper(IPC_CREAT | IPC_EXCL | 0666);
}

int GetShareMem()
{
    return GetShareMemHelper(IPC_CREAT);
}

#endif

processa.cc:

#include "common.hpp"
using namespace std;
extern Log mylog;
int main()
{
    int shmid= CreateShareMem();
    mylog(Debug,"shmid:%d",shmid);
    char* shmaddr = (char*)shmat(shmid,nullptr,0);
    mylog(Debug,"attach shm down,shmaddr:0x%x",shmaddr);
    sleep(5);

    shmdt(shmaddr);
    mylog(Debug,"detach shm down,shmaddr:0x%x",shmaddr);
    sleep(5);

    shmctl(shmid,IPC_RMID,nullptr);
    mylog(Debug,"destory shm down,shmaddr:0x%x",shmaddr);
    return 0;
}

processb.cc:

#include "common.hpp"
using namespace std;
extern Log mylog;
int main()
{
    int shmid= GetShareMem();
    mylog(Debug,"shmid:%d",shmid);
    char* shmaddr = (char*)shmat(shmid,nullptr,0);
    mylog(Debug,"attach shm down,shmaddr:0x%x",shmaddr);
    sleep(5);

    shmdt(shmaddr);
    mylog(Debug,"detach shm down,shmaddr:0x%x",shmaddr);
    sleep(5);

    // shmctl(shmid,IPC_RMID,nullptr);
    // mylog(Debug,"destory shm down,shmaddr:0x%x",shmaddr);
    return 0;
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 但是目前为止进程a和进程b并没有进行通信

共享内存创建出来后是给用户去使用的，当我们已经将它转化为字符串后我们可以将它当作字符串进行使用。（直接访问）

processa：

#include "common.hpp"
using namespace std;
extern Log mylog;
int main()
{
    
    int shmid= CreateShareMem();
    char* shmaddr = (char*)shmat(shmid,nullptr,0);
    
    //IPC code
    //一旦有人把数据写入到共享内存，其实我们立马能看到了
    //不需要经过系统调用，直接就能看到数据了
    while(true)
    {
        cout<<"client say@"<<shmaddr<<endl;//直接访问共享内存
    }

    shmdt(shmaddr);
    shmctl(shmid,IPC_RMID,nullptr);
    
    return 0;
}

processb:

#include "common.hpp"
using namespace std;
extern Log mylog;
int main()
{
    //一旦有了共享空间，挂接到自己的地址空间中，直接把它当成你的内存空间来用即可
    //不需要调用系统接口
    int shmid= GetShareMem();
    char* shmaddr = (char*)shmat(shmid,nullptr,0);
  
    //IPC code
    while(true)
    {
        //char buffer[1024];
        cout<<"Please Enter@";
        //fgets(buffer,sizeof(buffer),stdin);
        fgets(shmaddr,4096,stdin);
        //memcpy(shmaddr,buffer,strlen(buffer)+1);
    }

    shmdt(shmaddr);
    
    return 0;
}

共享内存的特性

  • 共享内存没有同步互斥之类的保护机制（所以需要被保护，可以结合管道进行使用）
  • 共享内存是所有的进程间通信中，速度最快的（拷贝少，采用地址空间映射的方法）
  • 共享内存内部的数据，由用户自己维护

共享内存扩展

  • man shmctl通过shmctl函数查看共享内存的属性

在这里插入图片描述

修改成这一串代码可以查看共享内存具体的属性

 struct shmid_ds shmds;
    while(true)
    {
        cout<<"client say@"<<shmaddr<<endl;//直接访问共享内存
        sleep(1);

        shmctl(shmid,IPC_STAT,&shmds);
        cout<<"shm size: "<<shmds.shm_segsz<<endl;
        cout<<"shm nattch: "<<shmds.shm_nattch<<endl;
        //cout<<"shm __key: " << shmds.shm_perm.__key<<endl;
        printf("shm __key:0x%x\n",shmds.shm_perm.__key);
        cout<<"shm mode: "<<shmds.shm_perm.mode<<endl;
        
    }

在这里插入图片描述

共享内存配合管道进行使用

common.h：

#ifndef __COMM_HPP__
#define __COMM_HPP__

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include "log.hpp"
using namespace std;


const string pathname = "/home/Harvey/ceshi/共享内存";
const int proj_id = 0x5555;
const int size = 4096;
Log mylog;

key_t GetKey()
{
    key_t k = ftok(pathname.c_str(),proj_id);
    if(k<0)
    {
        mylog(Fatal,"ftok error:%s",strerror(errno));
        exit(1);
    }
    mylog(Info,"ftok success!key is 0x%x",k);
    return k;
}

int GetShareMemHelper(int flag)
{
    key_t k =GetKey();
    int shmid = shmget(k,size,flag);
    if(shmid<0)
    {
        mylog(Fatal,"create share memory error:%s",strerror(errno));
        exit(2);
    }
    mylog(Info,"create share memory success,shmid:%d",shmid);
    return shmid;
}

int CreateShareMem()
{
    return GetShareMemHelper(IPC_CREAT | IPC_EXCL | 0666);
}

int GetShareMem()
{
    return GetShareMemHelper(IPC_CREAT);
}
#define FIFO_FILE "./myfifo"
#define MODE 0664

enum
{
    FIFO_CREATE_ERR = 1,
    FIFO_DELETE_ERR,
    FIFO_OPEN_ERR
};

class Init
{
public:
    Init()
    {
        // 创建管道
        int n = mkfifo(FIFO_FILE, MODE);
        if (n == -1)
        {
            perror("mkfifo");
            exit(FIFO_CREATE_ERR);
        }
    }
    ~Init()
    {

        int m = unlink(FIFO_FILE);
        if (m == -1)
        {
            perror("unlink");
            exit(FIFO_DELETE_ERR);
        }
    }
};
#endif

processa:

#include "common.hpp"

extern Log mylog;

int main()
{
    Init init;
    int shmid = CreateShareMem();
    char *shmaddr = (char*)shmat(shmid, nullptr, 0);

    // ipc code 在这里！！
    // 一旦有人把数据写入到共享内存，其实我们立马能看到了！！
    // 不需要经过系统调用，直接就能看到数据了！

    int fd = open(FIFO_FILE, O_RDONLY); // 等待写入方打开之后，自己才会打开文件，向后执行， open 阻塞了！
    if (fd < 0)
    {
        mylog(Fatal, "error string: %s, error code: %d", strerror(errno), errno);
        exit(FIFO_OPEN_ERR);
    }
    struct shmid_ds shmds;
    while(true)
    {
        char c;
        ssize_t s = read(fd, &c, 1);
        if(s == 0) break;
        else if(s < 0) break;

        cout << "client say@ " << shmaddr << endl; //直接访问共享内存
        sleep(1);

        shmctl(shmid, IPC_STAT, &shmds);
        cout << "shm size: " << shmds.shm_segsz << endl;
        cout << "shm nattch: " << shmds.shm_nattch << endl;
        printf("shm key: 0x%x\n",  shmds.shm_perm.__key);
        cout << "shm mode: " << shmds.shm_perm.mode << endl;
    }

    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, nullptr);

    close(fd);
    return 0;
}

processb:

#include "common.hpp"
extern Log mylog;
int main()
{
    int shmid = GetShareMem();
    char *shmaddr = (char*)shmat(shmid, nullptr, 0);

    int fd = open(FIFO_FILE, O_WRONLY); // 等待写入方打开之后，自己才会打开文件，向后执行， open 阻塞了！
    if (fd < 0)
    {
        mylog(Fatal, "error string: %s, error code: %d", strerror(errno), errno);
        exit(FIFO_OPEN_ERR);
    }
    // 一旦有了共享内存，挂接到自己的地址空间中，你直接把他当成你的内存空间来用即可！
    // 不需要调用系统调用
    // ipc code
    while(true)
    {
        cout << "Please Enter@ ";
        fgets(shmaddr, 4096, stdin);

        write(fd, "c", 1); // 通知对方
    }

    shmdt(shmaddr);

    close(fd);
    return 0;
}

运行结果：

在这里插入图片描述

爱写代码的刚子
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
【Linux】进程间通信（共享内存）
qq_43411866的博客
04-17 225
共享内存 1、实现原理： 共享内存区域说白了就是多个进程共享的一块物理内存地址，只是将这块物理内存分别映射到自己的虚拟空间地址上。 假设有 10 个进程将这块区域映射到自己的虚拟地址上，那么，这 10 个进程间就可以相互通信。 由于是同一块区域在10 个进程的虚拟地址上，当第一个进程向这块共享内存的虚拟地址中写入数据时， 其他 9 个进程也都会看到。 因此共享内存是进程间通信的一种最...
Linux进程间通信之共享内存
persistence_s的博客
06-03 636
共享内存的实现：两个不同进程共享同一块物理内存，达到访问同一份资源的目的 共享内存是所有进程间通信速度最快的一种方式，省去了数据的copy 在消息队列中就是server和client都读取了对方的数据并拷贝下来，因此有两次拷贝但是共享内存优缺点：他自身不提供同步于互斥机制（可以通过信号量来实现） 一般申请内存，都是按照一页的大小，避免内存碎片（4K为一页） 如果申请到的内存不够一页那么操作系
【Linux】进程间通信之共享内存
weixin_56916549的博客
08-17 289
共享内存原理 共享内存相关函数及命令 创建或获取共享内存函数 查看共享内存命令 删除共享内存命令 将共享内存附加到进程的虚拟地址空间 将共享内存与进程进行分离 操作共享内存
[ Linux ] 进程间通信之共享内存
CSDN博客
11-25 1289
[ Linux ] 进程间通信之共享内存
【Linux】进程间通信
最新发布
ZHENGZJM的博客
04-13 2226
介绍Linux中的进程间通信
【Linux】进程间通信——共享内存
qq_53830608的博客
11-11 1709
例2：进程A从键盘循环获取数据并拷贝到共享内存中，进程b从共享内存中获取并打印数据。要求进程a输入一次，进程b输出一次，a不输入，b就不输出。一般给0代表可读可写，可以给SHM_RDONLY 为只读模式，其他为读写。例1：进程A向共享内存写入数据，进程B从共享内存中读取数据并显示。A（./main)未输入时，B（./test）不输出（阻塞着）而输出的时候一直输出S内的数据，没有控制，会一直循环输出。正确流程是写入一次读取一次，不写入不读取。A输入end,A,B退出。A输入一个，B读取一个。
Linux进程间通信方式---共享内存
Black_MG的博客
02-14 259
共享内存的使用--代码
Linux进程间通信：共享内存
RYLUCK的博客
10-20 499
共享内存 它是不同进程之间共享的内存区域 共享内存是在多个进程之间共享内存区域的一种进程间的通信方式，它是在多个进程之间对内存段进行映射的方式实现内存共享的 是IPC最快的方式 共享内存方式直接将某内存段进行映射，多个进程间的共享内存是同一块的物理空间，仅仅是地址不同而已，因此不需要进行复制，可以直接使用此段空间 共享内存的特点 （1）共享内存就是允许两个不相关的进程访问同一个内存 （...
详解Linux进程间通信——使用共享内存
09-15
共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。这篇文章主要介绍了详解Linux进程间通信——使用共享内存，有兴趣的可以了解一下。
Python进程间通信之共享内存详解
01-20
前一篇博客说了怎样通过命名管道实现进程间通信，但是要在windows是使用命名管道，需要使用python调研windows api，太麻烦，于是想到是不是可以通过共享内存的方式来实现。查了一下，Python中可以使用mmap模块来实现...
linux通过共享内存实现进程之间的通信
05-23
自己做的一个ppt通过共享内存的方式实现进程间的通信
Linux环境进程间通信（五） 共享内存（上）
02-27
Linux环境进程间通信（五） 共享内存（上）
Linux进程间通信——共享内存
m0_53267045的博客
11-03 305
这样挂载一个共享内存如果是第一次调用时没有问题的，但是一个进程是可以对同一个共享内存多次shmat进行挂载的，物理内存是指向同一块，如果shmaddr为NULL,则每次返回的线性地址空间都不同，而且指向这块共享内存的引用计数会增加，也就是进程多块线性空间会指向同一块物理地址，这样会一直消耗进程的虚拟内存空间，很有可能会最后导致进程线性空间被使用完，而导致下次shmat或者其他操作失败。这样进程就与共享内存建立了连接。cat /proc/sys/kernel/shmmni
Linux进程间通信—共享内存
梅山
03-29 1874
共享内存不同于内存映射区，它不属于任何进程，并且不受进程生命周期的影响。通过调用 Linux 提供的系统函数就可得到这块共享内存。使用之前需要让进程和共享内存进行关联，得到共享内存的起始地址之后就可以直接进行读写操作了，进程也可以和这块共享内存解除关联，解除关联之后就不能操作这块共享内存了。在所有进程间通信的方式中共享内存的效率是最高的。 共享内存操作默认不阻塞，如果多个进程同时读写共享内存，可能出现数据混乱，共享内存需要借助其他机制来保证进程间的数据同步，比如：信号量，共享内存内部没有提供这种机制。 1
Linux进程间通信----＞共享内存
qq_56628506的博客
01-03 3776
Linux进程间通信之共享内存
Linux——进程间通信（共享内存【mmap实现+系统V】）
qq_44824574的博客
03-05 1956
共享内存 共享内存通过内核对象，使得不同的进程在自己的虚拟地址空间上分配一块空间映射到相同的物理内存空间上，这块物理内存空间对于映射到上面的每个进程而言都是可以访问的。(临界资源) 共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc()分配的内存一样。而如果某个进
linux c++ 进程间通信 共享内存
12-28
在Linux C编程中，可以通过使用共享内存机制来实现进程间通信。首先，需要通过系统调用shmget来创建一个共享内存区域，并返回一个唯一的标识符。然后使用shmat将共享内存附加到进程的地址空间中，使得进程可以访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱写代码的刚子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值