ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【Linux】详解如何利用共享内存实现进程间通信 [打印本页]
作者: 美食家大橙子    时间: 2024-7-17 16:45
标题: 【Linux】详解如何利用共享内存实现进程间通信
一、共享内存（Shared Memory）的熟悉

        共享内存（Shared Memory）是多进程间共享的一部分物理内存。它允许多个进程访问同一块内存空间，从而在不同进程之间共享和通报数据。这种方式常常用于加快进程间的通信，因为数据不必要在不同的进程间进行拷贝。
        在操作系统中，共享内存通常是通过映射一段能被其他进程所访问的内存实现的。一个进程可以创建一个共享内存段，并将该段连接到其地址空间中。其他进程也可以将这段共享内存连接到它们的地址空间中。这样，所有进程都可以访问同一段内存，实现数据的共享。
        在内核中共享内存可以存在许多个，操作系统必须先创建形貌共享内存的结构体，再把这些结构体组织起来管理。为了保证两个大概是多个进程看到同一个共享内存，就要给每一个共享内存提供唯一性的标识。
二、创建共享内存的方法


        创建共享内存的方法为shmget，其中第一个参数为key，key就是共享内存在内核中的唯一标识。size是要设置的共享内存的巨细（在内核中，共享内存是以4kb为根本单位的，我们在给共享内存分配巨细的时候最好也是分配4kb的整数倍的巨细。）。另有一个参数shmflg，shmflg可以有许多选项，但最常见的有两个：
             如果shmget成功获取或创建了共享内存段，它会返回一个非负整数，这个整数是共享内存段的标识符（也称为共享内存段的ID）。这个标识符在后续的共享内存操作中（如shmat和shmdt）会被利用。 
 2.1、key的获取


        这里的pathname是一串文件路径，proj_id是一个整数，这两个参数由用户随意指定，操作系统底层通过特定的算法帮我们形成一个key值，如果形成失败-1被返回。如果成功这个key值就会被设置进形貌共享内存的结构体中用来标识这块共享内存的唯一性。通过给两个进程大概是多个进程传入同样的pathname和proj_id就能让它们看到同一块共享内存。 
三、查看共享内存的方法

接纳ipcs指令可以查看系统中指定用户创建的共享内存，消息队列和信号量。
   ipcs -m：查看系统中指定用户创建的共享内存
  

    ipcs -q：查看系统中指定用户创建的消息队列
  

     ipcs -s：查看系统中指定用户创建的信号量
  

四、指令删除共享内存的方法

   ipcrm -m shmid（共享内存id）：删除用户指定的共享内存。 
  五、代码实现共享内存通信

5.1、获取key值

其实获取key可以封装成函数也可以不封装，这里我是将其封装成函数了。
  1. key_t get_key(const char* pathname, int proj_id)
  2. {
  3.     key_t key = ftok(pathname, proj_id);
  5.     //成功返回key值，失败返回-1
  6.     if(key == -1)
  7.     {
  8.         cout << "获取key值失败，原因是：" << strerror(errno) << endl;
  9.         exit(1);
  10.     }
  12.     return key;
  13. }
复制代码
5.2、创建共享内存

        共享内存是为了实现两方或是多方通信的，这里我就设置成为两方通信。以是一定是一方创建共享内存，另一方获取共享内存。要注意的是，共享内存也是有权限的，以是创建的一方必要指明创建的共享内存的权限。
  1. int get_or_create_shared_memory(key_t key, int size, int flag)
  2. {
  3.     int shmid = shmget(key, size, flag);
  5.     //成功返回共享内存标识符，失败返回-1
  6.     if(shmid == -1)
  7.     {
  8.         cout << "共享内存创建失败，原因是：" << strerror(errno) << endl;
  9.         exit(2);
  10.     }
  12.     return shmid;
  13. }
  15. int create_shared_memory(key_t key, int size)
  16. {
  17.     return get_or_create_shared_memory(key, size, IPC_CREAT | IPC_EXCL | 0666);
  18. }
  20. int get_shared_memory(key_t key, int size)
  21. {
  22.     return get_or_create_shared_memory(key, size, IPC_CREAT);
  23. }
复制代码
  5.3、挂接共享内存/去挂接共享内存


        shmid表示要挂接的共享内存的shmid，shmaddr表示要将该共享内存挂接到进程地址空间的什么位置，其实这个我们不用管，操作系统会自行帮我们挂接，可以直接设置为nullptr，shmflg表示可以对该共享内存做什么操作，设置为0默认是可读可写。 如果挂接成功，返回挂接到进程地址空间的地址，如果挂接失败，返回-1。
5.4、同步操作

        如果读写共享内存的进程间没有进行同步操作，可能就会发生脏读，即写入的数据和读到的数据不同等。以是要进行进程同步操作。这里我借助了管道来进行同步操作，即写方写完了再唤醒读方来读。
  1. #include <iostream>
  2. #include <cstring>
  3. #include <unistd.h>
  4. #include <sys/stat.h>
  5. #include <sys/types.h>
  6. #include <fcntl.h>
  7. #include <cstdio>
  9. using namespace std;
  11. #define MODE 0666 //权限
  12. #define NAME "./fifo.txt"
  14. //定义命名管道结构体
  15. class Fifo
  16. {
  17. private:
  18.     string _name; // 文件路径加文件名
  19. public:
  20.     Fifo(const string &name)
  21.         : _name(name)
  22.     {
  23.         int n = mkfifo(_name.c_str(), MODE);
  25.         if (n == 0)
  26.             cout << "创建管道成功！" << endl;
  27.         else
  28.             cout << "创建管道失败！原因是：" << strerror(errno) << endl;
  29.     };
  30.     ~Fifo()
  31.     {
  32.         int n = unlink(_name.c_str());
  34.         if (n == 0)
  35.             cout << "删除管道成功！" << endl;
  36.         else
  37.             cout << "删除管道失败！原因是：" << strerror(errno) << endl;
  38.     };
  39. };
  41. //同步结构体
  42. class Sync
  43. {
  44. private:
  45.     int rfd;
  46.     int wfd;
  47. public:
  48.     void open_read()
  49.     {
  50.         rfd = open(NAME, O_RDONLY);
  51.         if (rfd == -1)
  52.         {
  53.             cout << "读打开管道失败！" << endl;
  54.             exit(1);
  55.         }
  56.     }
  58.     void open_write()
  59.     {
  60.         wfd = open(NAME, O_WRONLY);
  61.         if (wfd == -1)
  62.         {
  63.             cout << "写打开管道失败！" << endl;
  64.             exit(1);
  65.         }
  66.     }
  68.     int wait()
  69.     {
  70.         int ret = 0;
  71.         int n = read(rfd, &ret, sizeof(int));
  72.         return n;
  73.     }
  75.     void wake_up()
  76.     {
  77.         int ret = 0;
  78.         int n = write(wfd, &ret, sizeof(int));
  79.     }
  80. };
复制代码
读写方分别创立一个sync对象，在读写的时候分别调用wait和wake_up方法进行同步。 
5.5、删除共享内存

         进程创建的共享内存如果在进程结束时没有开释，则共享内存会一直存在。也就是说，共享内存的声明周期是随内核的，如果我们没有自动去开释共享内存，除非重启系统，否则共享内存一直存在。以是在写端当你已经不写了时要将共享内存删掉。

 shmctl系统调用加上IPC_RMID选项可以删除共享内存。

  1. void shm_del(int shmid)
  2. {
  3.     int ret = shmctl(shmid, IPC_RMID, nullptr);
  4.     if (ret == -1)
  5.         cerr << "删除共享内存失败" << endl;
  6.     else
  7.         cout << "删除共享内存成功" << endl;
  8. }
复制代码
         shmctl的第三个选项可以传入一个形貌共享内存的对象的地址来获取该共享内存的属性，如果只是删除共享内存，直接设置为nullptr即可。
六、总结 

         共享内存不提供进程间协同的任何机制。但是共享内存是所有进程间通信机制中速率最快的。因为共享内存是通过页表直接与进程地址空间中的地址产生关联的，写方只必要将数据拷贝到共享内存中，读方直接通过地址就能访问内容，无需进行数据的拷贝，直接就提高了访问数据的速率。也就是说共享内存进行进程间通信只必要一次数据的拷贝，而我们之条件到的管道通信，都是读方调用write函数将数据写入内存（进行了一次拷贝），读方再调用read函数将数据拷贝到用户层，要进行两次数据的拷贝。
七、说明

        因为实现共享内存的文件数较多，以是以上并不是全部代码，如果想获取全部实现代码，请移步到本人码云：C++代码: C++代码保存的地方 - Gitee.com

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4