Linux共享内存

最新推荐文章于 2024-04-30 13:15:48 发布
最新推荐文章于 2024-04-30 13:15:48 发布
阅读量1.1k 收藏 14
点赞数 1
文章标签： linux 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Slowstep_/article/details/128267288
版权

文章目录

共享内存

共享内存是SystemV标准的一种进程间通信方式，基于SystemV标准的通信方式有共享内存、消息队列和信号量。

基本原理

共享内存的建立

共享内存指的是操作系统在物理内存中申请一块空间，让不同进程的页表都能映射到这一块内存区域，这样2个进程就看到了同一份资源。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-88dpt93n-1670665288572)(C:\Users\19199\Desktop\c++研发\Linux\共享内存.assets\image-20221206181450673.png)]

共享内存映射的区域是进程地址空间堆栈之间的镂空区域，共享内存和动态库所映射的区域都是进程地址空间堆栈之间的区域。

共享内存的释放

撤销共享内存与进程地址空间的映射，释放在物理内存中申请的共享内存的资源，同时回收管理共享内存的内核数据结构。

共享内存的基本认识

  • 共享内存是操作系统单独设计的一个内核模块，是操作系统专门为了进程间通信而设计的一种手段，共享内存的作用就是专门用来进行进程间通信。

  • 操作系统申请了共享内存，需要对共享内存进行管理，Linux系统需要知道如下问题：

    1. 共享内存的大小是多少？
    2. 有多少个进程的进程地址空间映射到了这一段共享内存？
    3. 这一段共享内存的其它属性？
    4. ……

    因此，Linux系统需要管理共享内存，管理共享内存的方法是先描述，在组织，只要申请了共享内存，在内核中一定要有管理这一段共享内存的内核数据结构。

  • 共享内存不单是一段物理内存空间，还有管理该空间的内核数据结构，共享内存=共享内存块+管理该共享内存块的内核数据结构

申请共享内存

申请共享内存使用系统接口shmget(shared memory get).

man 2 shmget

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

返回值：shmget函数申请共享内存成功会返回有效的共享内存用户层标识符，调用失败返回-1，并且errno被设置。

参数：

size_t size:想要申请的共享内存的大小，一般这个数值应该是4096Bytes的整数倍。如果申请4097Bytes,那么操作系统实际上会向内存申请4096*2Bytes,但是只给用户使用4097Bytes,剩下的空间虽然操作系统申请了，但是不会给用户使用，属于内存浪费。

shmflg:调用shmget函数时需要传入的选项，有IPC_CREAT和IPC_EXCL

如果只传IPC_CREAT:若在内核中存在共享内存，它的key值等于在shmget函数中传入的参数key,那么shmget函数返回这个共享内存的用户层标识符；若在内核中没有key值等于传入的key值的共享内存，那么Linux系统会在底层创建一个共享内存，让它的key值=传入的key值，然后返回这个共享内存的用户层标识符。

如果只传入IPC_EXCL:那么调用shmget函数是没有意义的

如果传入IPC_CREAT|IPC_EXCL:若在底层有一个共享内存的key值等于传入的key值，那么shmget函数返回-1，否则Linux系统在底层创建一个共享内存，这个共享内存的key值设置为传入的key值，返回这个共享内存的用户层标识符。使用IPC_CREAT|IPC_EXCL,只要shmget函数正常返回了，说明底层一定是创建了一个全新的共享内存。

shmget函数的第一个参数key:

共享内存=共享内存的内存块+管理共享内存的内核数据结构。第一个参数key是被写入到共享内存的内核数据结构中的，在内核中通过key值来区分不同的共享内存。

客户端在调用shmget时，使用IPC_CREAT选项，并且生成一个和服务端相同的key值传入shmget函数,客户端就能得到一个和服务端相同的用户层标识符，与服务端访问到同一段共享内存，实现进程间通信。

生成key值

生成key值使用ftok函数。

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

ftok函数的内部有特定的算法会生成一个随机的key值。

  • ftok函数会根据传入的第一个参数对应的文件(目录)的inode编号和传入的project_id,使用指定的算法生成一个特定的key值，只要参数一样，生成的key值就是一样的
  • 若ftok函数生成的key值与内核中某一个共享内存的key值一样的话，shmget(ftok(),…)会返回-1（选项是IPC_CREAT|IPC_EXCL）或返回这个共享内存的用户层标识符(IPC_CREAT)
  • ftok函数的第一个参数传入的路径应该是系统中存在的路径，而且最好要有访问权限，因为ftok是在文件系统中拿到传入的目录(文件)的inode编号,根据inode编号和project_id综合得出key值。
  • ftok函数的返回值：调用成功返回0，失败返回-1，errno被设置
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    key_t key = ftok("/home", 4);
    if (key == -1)
    {
        printf("ftok调用失败,可能是路径错误或没有对该路径的访问权限\n");
        exit(0);
    }
    printf("ftok(\"/hmoe\",4)产生的key值是%d\n", key);
    return 0;
}

key值与shmget函数的返回值

shmget函数的参数key只有在创建共享内存的时候才会使用到，这个key值是内核层面区分不同共享内存的标志，key值可以标定共享内存在系统层面的唯一性。

shmget函数的返回值是用户层标识符，用户层是通过shmget函数的返回值shmid来使用共享内存的,一般情况下对于共享内存的使用都是通过shmid,不会用到key.

共享内存的生命周期

共享内存的生命周期是随内核的，若通过shmget函数创建共享内存却不关闭的话，那么创建的这一个共享内存会一直存在于内核，占用系统资源，除非用户手动删除或重启设备。

#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<stdio.h>
#define PATH "/home/slowstep"
#define PROJECT_ID 4
#define SHM_SIZE 4096
int main(){
    int key=ftok(PATH,PROJECT_ID);//使用ftok产生一个随机的key
    if(key==-1){
        perror("ftok函数生成key发生错误");
        exit(1);
    }
    //ftok函数生成key成功,创建共享内存
    int shmid=shmget(key,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);//IPC_CREAT|IPC_EXCL,要么创建新的共享内存，要么失败，不会使用已经存在的共享内存。0666是创建的共享内存的权限，共享内存也有权限
    if(shmid==-1){
        perror("创建共享内存失败");
        exit(2);
    }
    printf("创建共享内存成功,shmid=%d\n",shmid);
    return 0;
}

使用ipcs -m命令查看系统中共享内存的属性

[slowstep@localhost shm]$ ipcs -m

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 4          slowstep   777        16384      1          dest         
0x00000000 5          slowstep   777        2129920    2          dest         
0x00000000 13         slowstep   600        524288     2          dest         
0x00000000 14         slowstep   600        524288     2          dest         
0x00000000 15         slowstep   777        2129920    2          dest         
0x00000000 16         slowstep   600        524288     2          dest         
0x04030040 17         slowstep   666        4096       0  #通过shmget创建的共享内存
  • key,共享内存在内核中的标识符
  • shmid,共享内存在用户层的标识符
  • owner,这个共享内存是谁通过shmget函数创建的
  • perms,共享内存的权限
  • bytes,共享内存的内存块大小，共享内存=共享内存的内存块+管理该内存块的内核数据结构，4096Bytes指的是前者，管理共享内存内存块的内核数据结构的大小需要另外计算。
  • nattch,有多少个进程与当前这个共享内存有关联，nattch=0表示没有进程与key值为0x04030040的共享内存有关联。

删除共享内存

由于共享内存的生命周期是随内核的，因此，若创建一个共享内存且使用完毕，应该删除它，否则会造成内存泄漏（存在无效的内存占用）。

删除共享内存使用命令ipcrm -m +shmid,shmid是共享内存的用户层标识符，用户层任何对于共享内存的操作都是通过shmid来进行的，除了创建共享内存（创建共享内存需要传入key）。

[slowstep@localhost shm]$ ipcs -m 

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 4          slowstep   777        16384      1          dest         
0x00000000 5          slowstep   777        2129920    2          dest         
0x00000000 13         slowstep   600        524288     2          dest         
0x00000000 14         slowstep   600        524288     2          dest         
0x00000000 15         slowstep   777        2129920    2          dest         
0x00000000 16         slowstep   600        524288     2          dest         
0x04030040 17         slowstep   666        4096       0                       

[slowstep@localhost shm]$ ipcrm -m 17
[slowstep@localhost shm]$ ipcs -m

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 4          slowstep   777        16384      1          dest         
0x00000000 5          slowstep   777        2129920    2          dest         
0x00000000 13         slowstep   600        524288     2          dest         
0x00000000 14         slowstep   600        524288     2          dest         
0x00000000 15         slowstep   777        2129920    2          dest         
0x00000000 16         slowstep   600        524288     2          dest

控制共享内存

shmctl接口可以控制共享内存

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

返回值：调用shmctl成功返回0，失败返回-1

参数：

shmid,要控制的共享内存在用户层的标识符

cmd:控制共享内存的方式。有IPC_STAT:获取共享内存的属性；IPC_SET:设置共享内存的属性；IPC_RMID:删除共享内存；IPC_INF:查看共享内存

buf:若只是删除共享内存的话，buf设置为NULL即可。

通过shmctl删除共享内存

#include<sys/ipc.h>
#include<sys/shm.h>
#include<iostream>
int main(){
    int key=ftok("/",4);
    if(key==-1){
        perror("ftok fail");
        exit(0);
    }
    int shmid=shmget(key,4096,IPC_CREAT|IPC_EXCL|0666);
    if(shmid<0){
        perror("shmget fail");
        exit(0);
    }
    std::cout<<"Creat shared memory success"<<std::endl;
    int ret=shmctl(shmid,IPC_RMID,nullptr);//删除共享内存
    if(ret<0){
        perror("shmctl(delete) fail");
    }
    printf("delete shared memory success\n");
    return 0;
}

通过shmctl删除共享内存有一个强势之处：无论是否有进程与该共享内存挂接，都会直接删除掉该共享内存。

共享内存的挂接

共享内存是有权限的，挂接共享内存需要有对共享内存的权限，共享内存的挂接过程就是把共享内存与进程地址空间建立映射的过程。

挂接共享内存使用shmat:shared memory attach.

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

参数：

  • shmid,要挂接的共享内存的用户层标识符
  • shmaddr,指定挂载到进程地址空间的虚拟地址，一般该参数可以设置为nullptr,表示让系统自动挂载
  • shmflg:挂载的方式，一般shmflg设置为0，表示默认以读写的方式进行挂载

返回值

如果挂接成功，返回挂接成功的起始地址（这个地址是进程地址空间的某一个虚拟地址），如果挂接失败返回(void*)-1

通过shmat函数返回的起始地址+偏移量就可以实现对共享内存的访问，当然这个访问是通过页表映射来访问的，不是通过虚拟地址直接访问的，偏移量指的就是共享内存的内存块大小

使用shmat完成挂接以后，共享内存的nattch属性会+1，表示多了一个进程与该共享内存产生关联。

取消挂接

将进程与指定的共享内存去除关联使用shmdt:shared memory detach

int shmdt(const void* shmaddr);

shmdt的参数是shmat函数返回的地址，shmdt调用成功返回0，失败返回-1，errno被设置。

#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<sys/shm.h>
#include<unistd.h>
#include<stdlib.h>
int main(){
    int key=ftok("/home",2);
    if(key<0){
        perror("ftok fail");
        exit(0);
    }
    printf("ftok success,key=%d\n",key);
    sleep(5);
    int shmid=shmget(key,4096,IPC_CREAT|IPC_EXCL|0666);
    if(shmid<0){
        perror("shmget fail");
        exit(0);
    }
    printf("shmget success ,shmid=%d\n",shmid);
    sleep(5);
    char* shmaddr=(char*)shmat(shmid,NULL,0);
    if(shmaddr==(char*)-1){
        perror("shmat fail");
        exit(0);
    }
    printf("shmat success,the return address is %p\n",shmaddr);
    sleep(5);
    int x=shmdt(shmaddr);
    if(x<0){
        perror("shmdt fail");
        exit(0);
    }
    printf("shmdt success\n");
    sleep(5);
    int y=shmctl(shmid,IPC_RMID,NULL);
    if(y<0){
        perror("shmctl(delete) fail");
        exit(0);
    }
    printf("delete success\n");
    sleep(5);
    return 0;
}

将2个进程挂接到同一个共享内存

consistant.hpp

#pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#define PATH "/home"
#define PROJECT_ID 5
#define SHM_SIZE 4096
using namespace std;

服务端Serve

/*
服务端
服务端创建共享内存
*/
#include "consistant.hpp"
int main(){
    try{
        int key=ftok(PATH,PROJECT_ID);
        if(key<0){
            throw "ftok fail";
        }
        printf("ftok success,key=%d\n",key);
        sleep(5);
        int shmid=shmget(key,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
        if(shmid<0){
            throw "shmget fail";
        }
        printf("shmget success,shmid=%d\n",shmid);
        sleep(5);
        //将进程地址空间与共享内存进行挂载
        char* shmaddr=(char*)shmat(shmid,NULL,0);//0,默认以读写方式进行挂载
        if(shmaddr==(char*)-1){
            throw "shmat fail";
        }
        printf("shmat success,shmaddr= %p\n",shmaddr);
        sleep(5);
        /*
        挂载完成可进行写入
        
        
        
        */
        //将进程与共享内存去除关联
        int ret=shmdt(shmaddr);
        if(ret<0){
            throw "shmdt fail";
        }
        printf("shmdt success\n");
        sleep(5);
        //使用shmctl删除共享内存
        int x=shmctl(shmid,IPC_RMID,nullptr);
        if(x<0){
            throw "shmctl(delete) fail";
        }
        printf("shmctl(delete) success\n");
        sleep(5);
    }
    catch(const char* errmessage){
        cout<<errmessage<<endl;
    }
    catch(...){
        cout<<"unknown exception"<<endl;
    }
    return 0;
}

客户端Client

/*
客户端
客户端通过接口连接共享内存
*/
#include "consistant.hpp"
int main(){
    try{
        int key=ftok(PATH,PROJECT_ID);
        if(key<0){
            throw "ftok fail";
        }
        printf("ftok success,key=%d\n",key);
        sleep(5);
        int shmid=shmget(key,SHM_SIZE,IPC_CREAT);//单独使用IPC_CREAT,如果key对应的共享内存存在，直接返回该共享内存在用户层的标识符
        if(shmid<0){
            throw "shmget fail";
        }
        printf("shmget success,shmid= %d\n",shmid);
        sleep(5);
        char* shmaddr=(char*)shmat(shmid,nullptr,0);
        if(shmaddr==(char*)-1){
            throw "shmat fail";
        }
        printf("shmat success,shmaddress= %p\n",shmaddr);
        sleep(5);
        /*
        挂接完成，可对共享内存进行读写操作
        
        
        */
        int ret=shmdt(shmaddr);
        if(ret<0){
            throw "shmdt dail";
        }
        printf("shmdt success\n");
        sleep(5);
        //删除共享内存由服务端完成
        
    }
    catch(const char* errmessage){
        cout<<errmessage<<endl;
    }
    catch(...){
        cout<<"unknown exception"<<endl;
    }
    return 0;
}

使用共享内存

共享内存可以直接使用，不用通过系统调用，类似于通过malloc申请了一块堆区空间。

进程地址空间的[0GB,3GB]属于用户空间，[3GB,4GB]属于内核空间，共享内存的挂接是把共享内存通过页表映射到进程地址空间的用户空间，映射到的区域是用户空间的堆栈之间。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvFexy6v-1670665288574)(C:\Users\19199\Desktop\c++研发\Linux\共享内存.assets\image-20221210165730925.png)]

使用共享内存：

consistant.hpp

#pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#define PATH "/home"
#define PROJECT_ID 5
#define SHM_SIZE 4096
using namespace std;

shmServe.cpp,服务端

/*
服务端
服务端创建共享内存
*/
#include "consistant.hpp"
#include<cstring>
int main(){
    int key=ftok(PATH,PROJECT_ID);
    if(key<0){
        perror("ftok fail");
        exit(0);
    }
    printf("ftok success,key=%d\n",key);
    int shmid=shmget(key,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
    if(shmid<0){
        perror("shmget fail");
        exit(0);
    }
    printf("shmget success,shmid=%d\n");
    char* shmaddr=(char*)shmat(shmid,nullptr,0);
    if(shmaddr==(char*)-1){
        perror("shmat fail");
        exit(0);
    }
    printf("shmat success,shmaddress=%p\n",shmaddr);
    //服务端从共享内存中读取数据
    while(true){
        if(strcmp("quit",shmaddr)==0){
            break;
        }
        printf("%s\n",shmaddr);
    }
    int ret=shmdt(shmaddr);
    if(ret<0){
        perror("shmdt fail");
        exit(0);
    }
    printf("shmdt success\n");
    int x=shmctl(shmid,IPC_RMID,nullptr);
    if(x<0){
        perror("delete fail");
        exit(0);
    }
    printf("delete success\n");
	return 0;
}

shmClient.cpp,客户端

/*
客户端挂接共享内存，并向共享内存中写入内容
*/
#include"consistant.hpp"
#include<cstring>
int main(){
    int key=ftok(PATH,PROJECT_ID);
    if(key<0){
        perror("ftok fail");
        exit(0);
    }
    printf("ftok success,key=%d\n",key);
    int shmid=shmget(key,SHM_SIZE,IPC_CREAT);
    if(shmid<0){
        perror("shmget fail");
        exit(0);
    }
    printf("shmget success,shmid=%d\n",shmid);
    char* shmaddr=(char*)shmat(shmid,nullptr,0);
    if(shmaddr==(char*)-1){
        perror("shmat fail");
        exit(0);
    }
    printf("shmat success,shmaddress=%p\n",shmaddr);
    //客户端向共享内存中写入内容
    while(true){
        ssize_t s=read(0,shmaddr,SHM_SIZE);
        shmaddr[s-1]='\0';
        if(strcmp(shmaddr,"quit")==0){
            break;
        }
    }
    int ret=shmdt(shmaddr);
    if(ret<0){
        perror("shmdt fail");
        exit(0);
    }
    printf("shmdt success\n");
    //删除共享内存由服务端完成
    return 0;
}
共享内存的特点

  • 共享内存在被创建以后会全部被初始化为0

  • 共享内存是所有进程间通信最快的方式，因为共享内存的使用不用经过系统调用接口，可以直接使用，这就有效的减少了拷贝的次数。

    如果使用管道通信需要发生4次拷贝，因为使用管道完成通信需要借助于系统调用接口read和write

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F5sDqCS1-1670665288575)(C:\Users\19199\Desktop\c++研发\Linux\共享内存.assets\image-20221210173402198.png)]

    而使用共享内存2个进程通过进程地址空间会映射到同一段共享内存，访问共享内存不需要经过系统调用，只会在读取数据和写入数据时发生2次数据的拷贝，没有中间过程会导致数据发生拷贝

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KBkQXZfT-1670665288575)(C:\Users\19199\Desktop\c++研发\Linux\共享内存.assets\image-20221210173603511.png)]

  • 共享内存没有同步和互斥，缺乏访问控制，会带来并发的问题。使用共享内存的时候，写端只负责写，读端只负责读，读写双方没有一定的顺序性。

    可以使用共享内存+管道，通过管道的方式实现访问控制。

    consistant.hpp

    #pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#include<fcntl.h>
#define PATH "/home"
#define PROJECT_ID 5
#define SHM_SIZE 4096
#define PIPENAME "./mypipe"
using namespace std;
class Pipe{
public:
    Pipe(){
        int ret=mkfifo(PIPENAME,0666);
        if(ret==-1){
            perror("Creat pipe fail");
            exit(0);
        }
        printf("Creat pipe success\n");
    }
    ~Pipe(){
        int ret=unlink(PIPENAME);
        if(ret==-1){
            perror("delete pipe file fail");
            exit(0);
        }
        printf("delete pipe file success\n");
    }
};

    shmServe.cpp

    /*
服务端
服务端创建共享内存
*/
#include "consistant.hpp"
#include<cstring>
int main(){
    try{
        int key=ftok(PATH,PROJECT_ID);
        if(key<0){
            throw "ftok fail";
        }
        printf("ftok success,key=%d\n",key);
        // sleep(5);
        int shmid=shmget(key,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
        if(shmid<0){
            throw "shmget fail";
        }
        printf("shmget success,shmid=%d\n",shmid);
        // sleep(5);
        //将进程地址空间与共享内存进行挂载
        char* shmaddr=(char*)shmat(shmid,NULL,0);//0,默认以读写方式进行挂载
        if(shmaddr==(char*)-1){
            throw "shmat fail";
        }
        printf("shmat success,shmaddr= %p\n",shmaddr);
        // sleep(5);
        /*
        服务端读取从客户端发送过来的消息
        */
        Pipe tmp;//创建管道，在析构函数中会自动删除命名管道
        int fd=open(PIPENAME,O_RDONLY);//服务端以读的方式打开管道文件
        while(true){
            char tmp[256]={0};
            read(fd,tmp,256);//如果读不到内容就会被阻塞,相当于使用管道间接实现了对于共享内存的访问控制
            if(strcmp("quit",shmaddr)==0){
                break;
            }
            printf("%s\n",shmaddr);
        }
        close(fd);
        //将地址空间与共享内存去除关联
        int ret=shmdt(shmaddr);
        if(ret<0){
            throw "shmdt fail";
        }
        printf("shmdt success\n");
        // sleep(5);
        //使用shmctl删除共享内存
        int x=shmctl(shmid,IPC_RMID,nullptr);
        if(x<0){
            throw "shmctl(delete) fail";
        }
        printf("shmctl(delete) success\n");
        // sleep(5);
    }
    catch(const char* errmessage){
        cout<<errmessage<<endl;
    }
    catch(...){
        cout<<"unknown exception"<<endl;
    }
    return 0;
}

    shmClient.cpp

    /*
客户端
客户端通过接口连接共享内存
*/
#include "consistant.hpp"
#include<cstring>
int main(){
    try{
        int key=ftok(PATH,PROJECT_ID);
        if(key<0){
            throw "ftok fail";
        }
        printf("ftok success,key=%d\n",key);
        // sleep(5);
        int shmid=shmget(key,SHM_SIZE,IPC_CREAT);//单独使用IPC_CREAT,如果key对应的共享内存存在，直接返回该共享内存在用户层的标识符
        if(shmid<0){
            throw "shmget fail";
        }
        printf("shmget success,shmid= %d\n",shmid);
        // sleep(5);
        char* shmaddr=(char*)shmat(shmid,nullptr,0);
        if(shmaddr==(char*)-1){
            throw "shmat fail";
        }
        printf("shmat success,shmaddress= %p\n",shmaddr);
        // sleep(5);
        /*
        挂接完成，可对共享内存进行读写操作
        客户端发送消息
        */
        //客户端以写的方式打开管道文件，随便向管道文件中写一些内容
        //服务端会读取管道中的内容，只要客户端不写入，服务端就会被阻塞
        int fd=open(PIPENAME,O_WRONLY);
        while(true){
            ssize_t s=read(0,shmaddr,SHM_SIZE);
            if(s){
                shmaddr[s-1]='\0';
                write(fd,"1111",256);
                if(strcmp("quit",shmaddr)==0){
                    break;
                }
            }
        }
        close(fd);
        int ret=shmdt(shmaddr);
        if(ret<0){
            throw "shmdt dail";
        }
        printf("shmdt success\n");
        // sleep(5);
        //删除共享内存由服务端完成
        
    }
    catch(const char* errmessage){
        cout<<errmessage<<endl;
    }
    catch(...){
        cout<<"unknown exception"<<endl;
    }
    return 0;
}
Slowstep_
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Linux共享内存实验的5个头文件
10-25
自己整理的Linux5个共享内存头文件， 通过编写共享内存实验，进一步了解使用共享内存的具体步骤，同时加深对共享内存的理解。在本实验中，采用信号量作为同步机制完善两个进程(“生产者”和“消费者”)之间的通信。
Linux——详解共享内存shared memory
热门推荐
weixin_61857742的博客
12-12 1万+
共享内存本质上就是内存中的一块区域，用于进程间通信使用。该内存空间由操作系统分配与管理。与文件系统类似的是，操作系统在管理共享内存时，不仅仅有内存数据块，同时还会创建相应结构体来记录该共享内存属性，以便于管理。因此，共享内存不只有一份，可以根据需求申请多个。进程之间进行通信的时候，会获取 到共享内存的地址，写端进程写入数据，读端进程通过直接访问内存完成数据读取。
【linux】共享内存
最新发布
yyqzjw的博客
04-30 678
1.shmget//创建共享内存key为用户给操作系统来标识共享内存的标识符，方便另一个进程来找到共享内存size为共享内存大小shmflg 创建共享内存的方式，位图形式返回shmid操作系统给用户的对应共享内存的操作符，用来对共享内存进行操作，比如说要释放共享内存，给shmctl函数传参shmid,要查看对应共享内存的属性，给shmctl也要传shmid2.ftok//产生一个随机值key,保证共享内存的唯一性pathname ：路径字符串（任意）proj_id：任意数值。
linux共享内存介绍
qq_34888036的博客
08-17 4977
由于进程通信的本质是要让两个不同的进程看到同一份资源，我们可以在物理内存上开辟一块空间，这块空间被称为共享内存，然后让这两个进程通过某种方式都能访问到这块内存，这样的话，两个进程之间就可以通信了。...
Linux 共享内存
小灰灰的博客
07-07 2512
创建共享内存：在Linux系统中，可以使用shmget函数来创建一个共享内存标识符。该函数需要指定共享内存的大小、权限等参数，并返回一个唯一的标识符。连接共享内存：使用shmat函数将进程与共享内存进行连接，该函数需要传入共享内存标识符和一个用户指定的地址，如果地址为0，则由系统选择一个可用的地址。使用共享内存：连接成功后，进程可以像使用普通内存一样使用共享内存，通过读写共享内存实现进程间的数据交换。分离共享内存：使用shmdt函数将进程与共享内存分离，分离后进程不能再访问共享内存。
linux 共享内存
09-16
概述 注意事项 软件包的来源 安装软件包需要注意的问题 编译程序 编译和安装 更多的资料 安装到系统中的文件
cpu_usage.rar_Linux共享内存
09-14
"cpu_usage.rar_Linux共享内存"是一个针对Linux系统的工具，用于统计CPU的使用情况，而且特别强调了采用共享内存的方式来实现。这个工具的设计旨在提高效率，减少不必要的I/O操作，因为共享内存允许多个进程之间快速...
linux共享内存
06-23
linux 共享内存的完整代码。 /* 共享内存 是一种常用的进程间通信机制。 1、创建内存共享区 2、映射内存共享区 3、进程间通信 4、撤销映射 5、删除内存共享区（一定要手动删除，不然会一直存在，哪怕程序结束...
【Linux】共享内存
zxj20041003的博客
07-20 1512
共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。
【Linux操作系统】共享内存
weixin_63449996的博客
06-23 2430
Linux操作系统——共享内存。
Linux：共享内存
qq_45481606的博客
08-05 2780
共享内存的原理 在物理内存中开辟一块空间； 不同进程通过页表将该空间映射到字节的进程虚拟地址空间中； 不同进程通过操作自己进程虚拟地址空间当中的虚拟地址，来操作共享内存； 使用共享内存步骤： 创建共享内存; 附加，将进程附加该共享内存上（将进程虚拟地址和物理地址通过页表建设映射关系）; 分离，将虚拟地址和物理地址的映射关系从页表中删除 共享内存映射到物理地址空间时 ，是映射在共享区中（在栈区和堆区中间） 共享内存接口： 1.创建或者获取共享内存 key_t ftok(const char
【Linux详解】——共享内存
HinsCoder的博客
09-05 1484
📖 前言：本期介绍共享内存。
【Linux】共享内存（超详细！）
zzxz8的博客
08-14 3964
通过在物理内存申请一段共享内存空间，这个空间可以被任何进程看见。然后将内存空间映射到想要以此进行通信的进程的进程地址空间中的共享区（堆栈之间），用户就可以直接使用这个虚拟起始地址进行数据传输和接收了。
【Linux篇】共享内存
m0_66492811的博客
08-22 444
共享内存
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值