【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
    评论
专栏目录
共享内存
qq_41027326的博客
04-01 198
    共享内存是最快的一种IPC形式（消息队列，共享内存，消息队列）。因为消息队列，管道等都需要用到系统接口，而共享内存则是直接改变逻辑地址到物理地址的映射关系，即当一个进程A看到这片内存时，对应的只要改变进程B的映射关系，此时进程B就可以立马看到这份公共资源 1.共享内存数据结构     其中的ipc_perm 是一个内核为每个 IPC 对象所维护的一个数据结构 2.共享内存...
Linux进程间通信之共享内存
07-26
本文主要介绍Linux进程间通信中共享内存的知识，感兴趣的朋友可以看看。
[linux]进程间通信（IPC）———共享内存（shm）（什么是共享内存，共享内存的原理图，共享内存的接口，使用演示）
2202_75305885的博客
02-22 1199
共享内存区是的（进程间通信）IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。：共享内存没有进行同步与互斥！共享内存不会自动销毁，要手动销毁。
【Linux】进程间通信
最新发布
ZHENGZJM的博客
04-13 2226
介绍Linux中的进程间通信
（P29）system v共享内存：共享内存数据结构 ，共享内存函数 ，共享内存eg
喜欢打篮球的普通人
05-05 726
文章目录1.共享内存数据结构2.共享内存函数3.共享内存eg 1.共享内存数据结构 共享内存示意图：共享内存可以映射到不同进程的地址空间 共享内存的数据结构如下： 当最后一个进程访问共享内存结束了，内核也不会自动删除共享内存段，除非显式删除共享内存或者内核自己删除共享内存 struct shmid_ds { //IPC对象都有 struct ipc_perm shm_p...
【Linux】共享内存
zxj20041003的博客
07-20 1420
共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。
详解Linux进程间通信——使用共享内存
09-15
共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。这篇文章主要介绍了详解Linux进程间通信——使用共享内存，有兴趣的可以了解一下。
Python进程间通信之共享内存详解
01-20
前一篇博客说了怎样通过命名管道实现进程间通信，但是要在windows是使用命名管道，需要使用python调研windows api，太麻烦，于是想到是不是可以通过共享内存的方式来实现。查了一下，Python中可以使用mmap模块来实现...
Linux环境进程间通信（五） 共享内存（上）
02-27
Linux环境进程间通信（五） 共享内存（上）
【Linux】共享内存（超详细！）
zzxz8的博客
08-14 3721
通过在物理内存申请一段共享内存空间，这个空间可以被任何进程看见。然后将内存空间映射到想要以此进行通信的进程的进程地址空间中的共享区（堆栈之间），用户就可以直接使用这个虚拟起始地址进行数据传输和接收了。
Linux进程间通信——共享内存
m0_53267045的博客
11-03 305
这样挂载一个共享内存如果是第一次调用时没有问题的，但是一个进程是可以对同一个共享内存多次shmat进行挂载的，物理内存是指向同一块，如果shmaddr为NULL,则每次返回的线性地址空间都不同，而且指向这块共享内存的引用计数会增加，也就是进程多块线性空间会指向同一块物理地址，这样会一直消耗进程的虚拟内存空间，很有可能会最后导致进程线性空间被使用完，而导致下次shmat或者其他操作失败。这样进程就与共享内存建立了连接。cat /proc/sys/kernel/shmmni
Linux进程间通信—共享内存
梅山
03-29 1875
共享内存不同于内存映射区，它不属于任何进程，并且不受进程生命周期的影响。通过调用 Linux 提供的系统函数就可得到这块共享内存。使用之前需要让进程和共享内存进行关联，得到共享内存的起始地址之后就可以直接进行读写操作了，进程也可以和这块共享内存解除关联，解除关联之后就不能操作这块共享内存了。在所有进程间通信的方式中共享内存的效率是最高的。 共享内存操作默认不阻塞，如果多个进程同时读写共享内存，可能出现数据混乱，共享内存需要借助其他机制来保证进程间的数据同步，比如：信号量，共享内存内部没有提供这种机制。 1
Linux进程间通信----＞共享内存
qq_56628506的博客
01-03 3776
Linux进程间通信之共享内存
Linux进程通信之共享内存
m0_60010936的博客
12-01 1272
Linux 共享内存
共享内存传递结构体类型的数据
天道酬勤
03-01 3947
一、firstprocess// #include &lt;windows.h&gt; #include &lt;stdio.h&gt; #include &lt;conio.h&gt; #include &lt;tchar.h&gt; #define BUF_SIZE 256 TCHAR szName[]=TEXT("Global\\MyFileMappingObject"); TCHAR s...
linux c++ 进程间通信 共享内存
12-28
在Linux环境下，进程间通信是实现多个进程之间数据交换和共享的重要手段之一。共享内存是一种进程间通信的方式，它允许多个进程访问同一块物理内存空间，从而实现数据的共享和传递。 在Linux C编程中，可以通过使用共享内存机制来实现进程间通信。首先，需要通过系统调用shmget来创建一个共享内存区域，并返回一个唯一的标识符。然后使用shmat将共享内存附加到进程的地址空间中，使得进程可以访问共享内存的数据。接着，可以通过对共享内存的读写操作来实现进程间数据的交换和共享。最后，使用shmdt来将共享内存从进程的地址空间中分离，最后再使用shmctl来控制共享内存区域的状态。 通过共享内存，不同的进程可以快速高效地进行数据交换，从而实现并发编程和协作。但是在使用共享内存时需要注意进程间数据同步和互斥访问的问题，以避免出现数据不一致或者冲突的情况。 总之，共享内存是Linux C编程中一种非常重要的进程间通信方式，它可以实现进程间数据的共享和传递，从而为多进程编程提供了便利和效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱写代码的刚子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值