Linux系统编程8：IPC共享内存

最新推荐文章于 2023-02-08 11:32:32 发布
最新推荐文章于 2023-02-08 11:32:32 发布
阅读量203 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42278523/article/details/107540946
版权

0. 共享内存

  • 比喻
    火锅

  • 本质

    • 多个进程访问同一个逻辑内存
    • 直接访问内存，不用read()/write()非常方便

在这里插入图片描述

1. POSIX 共享内存

  • 资料：unpv22e-ch13
  • 查看：
    • man shm_overview
    • ls /dev/shm

2. 分类

  1. 内存映射文件
    在这里插入图片描述

内存映射文件

注意：共享内存大小 = 文件大小

  1. 共享内存区对象(非亲缘进程)
    在这里插入图片描述

  2. 匿名内存映射(亲缘进程)

风格方式
BSDMAP_ANON+mmap()
Systerm V/dev/zero+open()

3 接口

  • 头文件：sys/mman.h
  • 库：librt.so

3.1 函数

POSIX 共享内存有6个函数,其中5,6为文件操作函数，使用内存映射文件。

No.操作函数
1创建int shm_open(const char *name, int oflag, mode_t mode)
2删除int shm_unlink(const char *name)
3建立内存映射void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset)
4关闭内存映射int munmap(void *start,size_t length)
5获取文件信息int fstat(int fd,struct stat *buf))
6关闭内存映射int ftruncate(int fd,struct stat *buf,off_t length))

*案例：查看文件大小并进行修改，可以变成0；
./filename file_name new_size

  1. 头文件
#include <fcntl.h> // open() O_RDONLY
#include <sys/stat.h> // stat()
#include <unistd.h> // ftruncate()
  1. atoi（）将字符串转化为数字
truncate(argv[1],atoi(argv[2]));  //（2）atoi（）将字符串转化为数字
  1. 表示文件执行的时候的参数说明（终端输入）
int main(int argc,char* argv[]){  //（1）表示文件执行的时候的参数类型（终端输入）

补充说明代码（main.cpp）

#include <iostream>
using namespace std;

int main(int argc,const char* const argv[]){
    for(int i=0;i<argc;++i){
        cout << i << ":" << argv[i] << endl;
    }
}
  • 完整案例
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h> // open() O_RDONLY
#include <sys/stat.h> // stat()
#include <unistd.h> // ftruncate()
using namespace std;
// ./filesize file_name new_size
int main(int argc,char* argv[]){  //（1）表示文件执行的时候的参数类型（终端输入）
    if(3!=argc){
        cout << "Using:" << argv[0] << " file_name new_size"  << endl;
        return EXIT_FAILURE;
    }
/*
    int fd = open(argv[1],O_RDWR);
    if(-1 == fd){
        perror("open file error");
        return EXIT_FAILURE;
    }

    struct stat s;
    fstat(fd,&s);
    cout << argv[1] << ":"<< s.st_size << endl;

    ftruncate(fd,atoi(argv[2]));

    fstat(fd,&s);
    cout << argv[1] << ":"<< s.st_size << endl;
*/
    struct stat s;
    stat(argv[1],&s);
    cout << argv[1] << ":"<< s.st_size << endl;

    truncate(argv[1],atoi(argv[2]));  //（2）atoi（）将字符串转化为数字

    stat(argv[1],&s);
    cout << argv[1] << ":"<< s.st_size << endl;
    return EXIT_SUCCESS;
}

3.1.1 创建

  int shm_open(const char *name, int oflag, mode_t mode)
  • 参数
No.参数含义
1nameposix IPC名字，格式为/somename
2oflag标志
3mode权限
  • 标志
No.标志作用
1O_CREAT没有该对象则创建
2O_EXCL如果O_CREAT指定，但name不存在，就返回错误
3O_NONBLOCK以非阻塞方式打开消息队列
4O_RDONLY只读
5O_RDWR读写
6O_WRONLY只写
7O_TRUNC若存在则截断
  • 权限
No.权限作用
1S_IWUSR用户/属主写
2S_IRUSR用户/属主读
3S_IWGRP组成员写
4S_IRGRP组成员读
5S_IWOTH其他用户写
6S_IROTH其他用户读
  • 返回值
No.返回值含义
1-1出错
2其他共享内存描述符
  • 创建内存共享
    1.编写源代码
    1.1参数（1,文件名，2,操作方式3，权限）
int fd = shm_open(argv[1],O_CREAT|O_RDWR,0644); //参数（1,文件名，2,操作方式3，权限）
  • 完整案例
   #include <iostream>
#include <cstdlib>
#include <cstdio>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()

using namespace std;

// ./shm_open file_name file_size
int main(int argc,char* argv[]){

   if(3 != argc){
        cout << "Using:" << argv[0] << " file_name file_size" << endl;
        return EXIT_FAILURE;
   }

   // 创建共享内存文件 
   int fd = shm_open(argv[1],O_CREAT|O_RDWR,0644); //参数（1,文件名，2,操作方式3，权限）
   if(-1 == fd){
        perror("create error");
        return EXIT_FAILURE;
   }

   // 1.2 一定要修改大小
   ftruncate(fd,atoi(argv[2]));

   return EXIT_SUCCESS;
}

1.2编译：,注意连接库

g++ 002_shm_open.cpp -o 002_shm_open -lrt

1.3执行：,二进制文件名 /文件名 size
注意：文件存在/dev/shm里面

./002_shm_open /abc 200

ll /dev/shm

3.1.2 删除

int shm_unlink(const char *name)
  • 参数
No.参数含义
1nameposix IPC名字
  • 返回值
No.返回值含义
1-1出错
20成功
  • 示例

1.编写源码

 #include <iostream>
#include <cstdlib>
#include <cstdio>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()

using namespace std;

// ./shm_unlink file_name
int main(int argc,char* argv[]){

   if(2 != argc){
        cout << "Using:" << argv[0] << " file_name" << endl;
        return EXIT_FAILURE;
   }

   // 删除
   int res = shm_unlink(argv[1]);
   if(-1 == res){
        perror("delete error");
        return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
}

1.2编译：,注意连接库

g++ 002_shm_unlink.cpp -o 002_shm_unlink -lrt

1.3执行：,二进制文件名 /文件名
注意：文件存在/dev/shm里面

./002_shm_unlink /abc 

ll /dev/shm

3.1.3 建立内存映射

void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset)
  • 参数
No.参数含义
1start映射区的开始地址，通常使用NULL，让系统决定映射区的起始地址
2length”映射区的长度，单位字节，不足一内存页按一内存页处理
3prot内存保护标志
4flags映射对象的类型
5fd文件描述符，不能是套接字和终端的fd，-1为匿名内存映射
6offset被映射对象内容的起点，只能是页大小的整数倍

如何获取页大小? sysconf(_SC_PAGESIZE)

  • 内存保护标志
No.参数含义
1PROT_EXEC页内容可以被执行
2PROT_READ页内容可以被读取
3PROT_WRITE页可以被写入
4PROT_NONE页不可访问，不能与文件的打开模式冲突
  • 映射对象的类型
No.参数含义
1MAP_SHARED变动共享
2MAP_PRIVATE变动私有
3MAP_ANON匿名内存映射
  • 返回值
No.返回值含义
1MAP_FAILED失败
2非MAP_FAILED共享内存地址

3.1.4 关闭内存映射

int munmap(void *start,size_t length)
  • 参数
No.参数含义
1start映射内存起始地址
2length内存大小
  • 返回值
No.返回值含义
10成功
2-1失败
  • 注意
    关闭mmap中的文件描述符不能删除内存映射。

3.2 内存映射文件

3.2.1 写文件

1.1编写源码
(1.1.1) 创建文件;(注意shm_open()里面的参数)

  int fd = shm_open(argv[1],O_RDWR,0);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }

(1.1.2) 建立映射
参数一;默认为空；随机访问（系统）
参数二：大小
参数三;操作；
参数四：权限（共享）
参数五：描述符
参数六：返回的指针大小，默认

 void* buf = mmap(NULL,100,PROT_WRITE,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }

1.1.3内存操作,默认为memcpy，这里特化为strcpy

 string str;
   getline(cin,str);
   strcpy(reinterpret_cast<char*>(buf),str.c_str())

1.1.4 解除映射
munmap(buf,100);

  • 完整案例
   #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()
#include <cstring> //strcpy()

using namespace std;

// ./shm_write file_name
int main(int argc,char* argv[]){

   if(2 != argc){
        cout << "Using:" << argv[0] << " file_name" << endl;
        return EXIT_FAILURE;
   }

   // （1） 创建文件;(注意shm_open()里面的参数)
   int fd = shm_open(argv[1],O_RDWR,0);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }

   // （2）建立映射
   //参数一;默认为空；随机访问（系统）
//参数二：大小
//参数三;操作；
//参数四：权限（共享）
//参数五：描述符
//参数六：返回的指针大小，默认
   void* buf = mmap(NULL,100,PROT_WRITE,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
   
   // 1.3内存操作,默认为memcpy，这里特化为strcpy
   string str;
   getline(cin,str);
   strcpy(reinterpret_cast<char*>(buf),str.c_str());

   //1.4 解除映射
   munmap(buf,100);

   return EXIT_SUCCESS;
}

1.2 编译

g++ 004_shm_write.cpp -o 004_shm_write -lrt

1.3 执行

./004_shm_write /abc
abcdefg
  • 问题
    如果没有ftruncate(fd,sizeof(str));会出现什么情况？（不能修改大小）

3.2.2. 读文件

2.1源码
2.1.1读操作，注意参数

 // 建立映射
   void* buf = mmap(NULL,100,PROT_READ,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
  • 完整案例
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()
#include <cstring> //strcpy()

using namespace std;

// ./shm_read file_name
int main(int argc,char* argv[]){

   if(2 != argc){
        cout << "Using:" << argv[0] << " file_name" << endl;
        return EXIT_FAILURE;
   }

   // 打开共享内存文件
   int fd = shm_open(argv[1],O_RDWR,0);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }

   // 建立映射
   void* buf = mmap(NULL,100,PROT_READ,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
   
   cout << reinterpret_cast<char*>(buf) << endl;

   // 解除映射
   munmap(buf,100);

   return EXIT_SUCCESS;
}

2.2 编译

g++ 005_shm_read.cpp -o 005_shm_read -lrt

2.3 执行

./005_shm_write /abc

4.非亲缘

4.1 普通非亲缘. 非亲缘进程读写数据

  1. 写
 #include <stdio.h>
    #include <unistd.h>
    #include <sys/mman.h>
    #include <fcntl.h>
    #include <string.h>
     
    int main(int argc,char* argv[]){
        int fd = open("./mmap.txt",O_CREAT|O_RDWR,0644);
        void* buf = NULL;
        if(( buf =  mmap(NULL,BUFSIZ,PROT_WRITE|PROT_READ,MAP_SHARED,fd,0)) == MAP_FAILED){
            perror("mmap error\n");
            return 1;
        }
        strcpy(buf,argv[1]);    
        munmap(buf,BUFSIZ);
        close(fd);
    }
  1. 读
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
 
int main(int argc,char* argv[]){
    int fd = open("./mmap.txt",O_CREAT|O_RDWR,0644);
    void* buf = NULL;
    if(( buf =  mmap(NULL,BUFSIZ,PROT_WRITE|PROT_READ,MAP_SHARED,fd,0)) == MAP_FAILED){
        perror("mmap error\n");
        return 1;
    }
    printf("%s\n",buf);
    munmap(buf,BUFSIZ);
    close(fd);
}

4.2 共享内存区对象(非亲缘进程)

  1. 写
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
 
int main(int argc,char* argv[]){
    int fd = shm_open(argv[1],O_RDWR,0);
    void* buf = NULL;
    if(( buf =  mmap(NULL,BUFSIZ,PROT_WRITE,MAP_SHARED,fd,0)) == MAP_FAILED){
        perror("mmap error\n");
        return 1;
    }
    int i;
    for(i=2;i<argc;i++){
        strcpy(buf,argv[i]);    
        sleep(3);
    }
    munmap(buf,BUFSIZ);
    close(fd);
}
  1. 读
#include <stdio.h>
    #include <unistd.h>
    #include <sys/mman.h>
    #include <fcntl.h>
    #include <string.h>
     
    int main(int argc,char* argv[]){
        int fd = shm_open(argv[1],O_RDONLY,0);
        void* buf = NULL;
        if(( buf =  mmap(NULL,BUFSIZ,PROT_READ,MAP_SHARED,fd,0)) == MAP_FAILED){
            perror("mmap error\n");
            return 1;
        }
        sleep(1);
        for(;;){
            printf("read:%s\n",buf);
            sleep(3);
        }
        munmap(buf,BUFSIZ);
        close(fd);
    }

5 亲缘进程

5.1 亲缘进程读写数据（实名）

  1. 打开共享内存文件
   int fd = shm_open(argv[1],O_RDWR,0);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }
  1. 建立映射
  char* buf = (char*)mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
  1. 父子进程
 if(0==fork()){ //子进程
        strcpy(buf,"Test");
   }else{ // 父进程
        cout << buf << endl;
   }
  • 完整案例
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()
#include <cstring> //strcpy():

using namespace std;

// ./shm_read file_name
int main(int argc,char* argv[]){

   if(2 != argc){
        cout << "Using:" << argv[0] << " file_name" << endl;
        return EXIT_FAILURE;
   }

   // 打开共享内存文件
   int fd = shm_open(argv[1],O_RDWR,0);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }

   // 建立映射
   char* buf = (char*)mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
   
   // 
   if(0==fork()){ //子进程
        strcpy(buf,"Test");
   }else{ // 父进程
        cout << buf << endl;
   }

   // cout << reinterpret_cast<char*>(buf) << endl;

   // 解除映射
   munmap(buf,100);

   return EXIT_SUCCESS;
}

5.2 亲缘进程读写数据（匿名1）

  • Systerm V风格
  1. 打开匿名共享内存
   int fd = open("/dev/zero",O_RDWR);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }
  1. 建立映射
char* buf = (char*)mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
  1. 父子进程
  if(0==fork()){ //子进程
        strcpy(buf,"Test");
   }else{ // 父进程
        sleep(1);
        cout << buf << endl;
   }
  • 完整案例
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()
#include <cstring> //strcpy()

using namespace std;

// ./shm_read file_name
int main(int argc,char* argv[]){

/*   if(2 != argc){
        cout << "Using:" << argv[0] << " file_name" << endl;
        return EXIT_FAILURE;
   }
*/
   // 打开匿名共享内存
   int fd = open("/dev/zero",O_RDWR);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }

   // 建立映射
   char* buf = (char*)mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
   
   // 
   if(0==fork()){ //子进程
        strcpy(buf,"Test");
   }else{ // 父进程
        sleep(1);
        cout << buf << endl;
   }

   // cout << reinterpret_cast<char*>(buf) << endl;

   // 解除映射
   munmap(buf,100);

   return EXIT_SUCCESS;
}

5.3 亲缘进程读写数据（匿名2）

. * BSD风格

  1. 建立映射(不用建立共享文件 )
 char* buf = (char*)mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
  1. 父子进程
   if(0==fork()){ //子进程
        strcpy(buf,"Test");
   }else{ // 父进程
        sleep(1);
        cout << buf << endl;
   }
  • 完整案例
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h> // O_CREAT
#include <sys/mman.h> // shm_open()
#include <unistd.h> // ftruncate()
#include <cstring> //strcpy()

using namespace std;

// ./shm_read file_name
int main(int argc,char* argv[]){

/*   if(2 != argc){
        cout << "Using:" << argv[0] << " file_name" << endl;
        return EXIT_FAILURE;
   }
*/
   // 打开匿名共享内存
/*
   int fd = open("/dev/zero",O_RDWR);
   if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
   }
*/
   // 1. 建立映射(不用建立共享文件 )
   char* buf = (char*)mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);
   if(MAP_FAILED == buf){
        perror("mmap error");
        return EXIT_FAILURE;
   }
   
   // 2.父子进程
   if(0==fork()){ //子进程
        strcpy(buf,"Test");
   }else{ // 父进程
        sleep(1);
        cout << buf << endl;
   }

   // cout << reinterpret_cast<char*>(buf) << endl;

   // 解除映射
   munmap(buf,100);

   return EXIT_SUCCESS;
}

5.4 结果

比较
在这里插入图片描述

实验
使用gdb查看共享内存的建立映射和解除映射。

info proc mapping

6. 使用mmap容易出现的问题

  1. 现象：总线错误Bus Error
    原因：映射文件的大小为0
    解决：使用ftruncate()扩展文件的大小，stat.st_size。
  2. 现象：段错误
    原因：munmap()解除映射的大小大于申请内存大小
    解决：解除映射大小与申请内存大小保持一直
  3. 现象：Permisstion denied
    原因：文件打开权限与文件映射对象访问权限不一致。
    解决：只读PROT_READ的文件映射对象使用O_RDONLY打开文件；读写PROT_READ|PROT_WRITE的文件映射对象使用O_RDWR打开文件
阿华田咯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux系统编程：IPC共享内存
凯凯在此
08-12 206
文章内容1. POSIX 共享内存2. 函数2.1 创建内存映射 1. POSIX 共享内存 查看： 共享内存一般生成在 ls /dev/shm ls /dev/ 看到绿色的文件都是用来通信的 接口： 头文件： sys/mman.h 库： librt.so 2. 函数 操作 函数 创建 int shm_open(const char *name, int oflag, mode_t mode) 删除 int shm_unlink(const char *name) 建立内存映射 v
Linux进阶-ipc共享内存
最新发布
weixin_47077788的博客
10-17 453
当不为NULL时，SHMFLG必须设置为SHM_RND，系统将会选择比shmaddr小而又最大的页对齐地址（即为SHMLBA的整数倍）作为共享内存区域的起始地址。共享内存思想：进程间虚拟内存空间本来相互独立，不能相互访问，但是可以通过某种方式使得相同的一块物理内存多次映射到不同的进程虚拟空间中，相当于多个进程的虚拟内存空间部分重叠在一起。共享内存：将内存进行共享，它允许多个不相关的进程访问同一个逻辑内存，直接将一块裸露的内存放在需要数据传输的进程前，供进程使用。，因此所有进程都可访问共享内存的地址。
linux IPC---共享内存
牛仔的blog
08-16 2727
共享内存共享内存是允许两个或多个进程共享同一块内存区域，因为进程可以直接读写内存，不需要任何数据的拷贝，这是一种最快的进程间通信方式。共享内存是多进程之间的通信方法 ,这种方法通常用于一个程序的多进程间通信，实际上多个程序间也可以通过共享内存来传递信息。当然，多个进程同时访问共享区就得需要一些同步机制，如信号量或互斥锁等，这些以后再记录，本文先讲最简单的共享内存使用方式。linux共享内存操作的四个
Linux内核IPC源码——共享内存
生活需要深度
02-08 655
0]. sem->count的数值>=0, 如果count>0, 说明当前信号量没有被占用, 可以获取;如果countlist来添加等待任务或者唤醒任务;[0]. 定义信号量结构体变量;[1]. 初始化信号量变量。
Linux C unlink函数
yekui006的博客
03-17 715
相关函数：link, rename, remove 头文件：#include <unistd.h> 定义函数：int unlink(const char * pathname); 函数说明：unlink()会删除参数pathname 指定的文件. 如果该文件名为最后连接点, 但有其他进程打开了此文件, 则在所有关于此文件的文件描述词皆关闭后才会删除. 如果参数pathname 为一符号连接, 则此连接会被删除。 返回值：成功则返回0, 失败返回-1, 错误原因存于errno 错误代码： 1、ER
linux系统编程_linux系统编程-中文_
10-04
系统调用是Linux编程的核心，比如`fork()`用于创建新进程，`exec()`系列函数用于替换当前进程的执行体，`wait()`和`waitpid()`用于等待子进程结束，`open()`、`read()`和`write()`用于文件操作，`close()`用于关闭...
Linux系统编程PPT.zip
07-10
学习如何创建、管理和控制进程和线程至关重要，包括进程间通信（IPC）机制，如管道、信号量、共享内存和消息队列。这部分还会讨论线程同步和死锁问题，以确保程序的正确运行。 最后，“进程间通信”章节将深入研究...
解决Linux system v 共享内存问题
09-14
在Linux系统中，System V接口提供了共享内存机制，这是一种允许多个进程之间共享数据的方法，而无需通过文件或网络通信。共享内存提供了高速、低延迟的数据交换途径，因为数据直接存储在内存中，可供多个进程访问。...
linux下c语言编程4-使用共享内存实现进程间通信.pdf
11-01
在Linux系统中，C语言编程实现进程间通信（IPC，Inter-Process Communication）时，共享内存是一种高效且直接的方式。共享内存允许多个进程访问同一块内存区域，从而实现在进程间的数据交换。以下是对标题“linux下...
linux 共享内存方式
SWX230162的博客
12-24 860
linux 共享内存方式
C/C++ linux 实现共享内存（share memory）的读写操作【代码实例】
热门推荐
Aliven888的博客
07-30 1万+
什么是共享内存？ 简单来说，共享内存就是允许两个或多个进程共享一定的存储区。
linux进程间通信(IPC) --- 共享内存
weixin_52495715的博客
12-27 547
共享内存概述 共享内存允许两个或者多个进程共享给定的存储区域 共享内存的特点 1.共享内存是进程间共享数据的一种最快的方法 一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容 2.使用共享内存要注意的是多个进程之间对一个给定存储区访问的互斥 若一个进程正在向共享内存区写数据，则在它做完这一步操作前，别的进程不应当去读，写这些数据。 上面图片讲解： 左右两边每一个进程在创建的时候，都会给它分配4G的虚拟内存，所以左右两边的空间叫做虚拟内存，而中间的是物理内存，也就是内存条
共享内存—shmget参数shmflg详解—IPC_CREAT、IPC_EXCL、0666(对内存的读写执行权限)
KgdYsg的博客
03-07 2131
int shmget(key_t key, size_t size, int flag); key: 标识符的规则 size: 共享存储段的字节数 flag: 读写的权限还有IPC_CREAT或IPC_EXCL对应文件的O_CREAT或O_EXCL 返回值： 成功返回共享存储的id，失败返回-1 1 key_t key key标识共享内存的键值: 0/IPC_PRIVAT...
进程间通信（IPC）：共享内存
swint_er的博客
07-05 454
进程间通信（IPC）：共享内存。共享内存是先在物理内存上申请一块空间，多个进程可以将其映射到自己的虚拟地址空间中。所有进程都可以访问共享内存中的地址，就好像它们是由 malloc 分配的一样。如果某个进程向共享内存写入了 数据，所做的改动将立刻被可以访问同一段共享内存的任何其他进程看到。由于它并未提供同步机制，所以我们通常需要用其他的机制.........
Linux IPC 共享内存
weixin_30477293的博客
07-08 83
共享内存时IPC形式中最快的一种。 POSIX 共享内存 posix.1提供了两种在无亲缘关系的进程间共享内存的方式 （1）内存映射文件：由open函数打开一个文件，由mmap函数把得到的描述符映射到当前进程地址空间中。 （2）共享内存区对象：由shm_open打开一个Posix.1 IPC名字（通常是文件系统中的一个路径名），所返回的描述符由mmap函数映射到当前进程地址空间。 ...
共享内存的读写
常驻
11-26 1307
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h>#define BUFFER_SIZE 2048int main() { pid_t pid; int shmid; char *s
EsgynDB中的共享内存
badboynt的博客
08-30 406
假设在第一个进程中，一片共享内存映射到基地址0x10000000处，这片共享内存里有个指针本身的地址为0x10000100, 其指向的地址为0x10000200, 这片共享内存被第二个进程映射到基地址0x2000000处，第二个进程通过偏移0x100可以访问这个指针，但是这个指针指向的仍然是0x10000200，通过指针访问对应内存就会产生不可预知的错误。如果CacheEntry这个类有虚函数，虚函数表编译后是个固定的数据存放在数据区，程序每次运行的时候，会有一个动态绑定的过程。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值