devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux--进程间通信（system V共享内存）

作者：IT小白 | 2024-06-11 15:28:43

赞

踩

Linux--进程间通信（system V共享内存）

目录

1.原理部分

 2.系统调用接口

参数说明

返回值

1. 函数原型

2. 参数说明

3. 返回值

4. 原理

5. 注意事项

3.使用一下shmget（一段代码） 

4.一个案例（一段代码)

1.简单封装一下

2.使用共享内存

 2.1挂接（shmat）和取消挂接（shmdt）

2.2重新封装

2.3使用共享内存进行通信

 5.共享内存的优劣

优点：

缺点：

1.原理部分

以shmget系统调用为例：

  1. 创建共享内存区域：
    • 使用shmget系统调用来请求创建一块共享内存区域。这个函数会分配一块指定大小的内存，并返回一个标识符（shmid），用于后续对这块共享内存的引用。
    • 在创建过程中，System V共享内存会在内核中创建一个特殊的数据结构（如shmid_kernel）来描述这块共享内存，并在特殊文件系统shm中创建一个与该共享内存关联的文件。
  2. 映射共享内存到进程地址空间：
    • 通过shmat系统调用，进程可以将之前创建的共享内存区域映射到自己的虚拟地址空间中。这样，进程就可以通过指针直接访问这块共享内存，而无需通过内核进行数据的拷贝。
    • shmat调用会返回一个指向共享内存区域的指针，进程可以使用这个指针来读写共享内存中的数据。
  3. 进程间通信：
    • 当多个进程都映射了同一块共享内存到各自的地址空间后，它们就可以通过读写这块共享内存来进行通信了。
    • 进程A可以将数据写入共享内存，然后进程B可以从共享内存中读取这些数据，从而实现进程间的数据交换。
  4. 解除映射和删除共享内存：
    • 当进程不再需要访问共享内存时，可以使用shmdt系统调用来解除映射，即将共享内存从进程的地址空间中移除。
    • 当所有进程都解除了对共享内存的映射，并且确定不再需要这块共享内存时，可以使用shmctl系统调用来删除它，释放系统资源。

 2.系统调用接口

shmget

  • 功能：创建或获取共享内存。
  • 参数：
    • key_t key：一个键值，用于唯一标识一个共享内存段。你可以使用IPC_PRIVATE常量创建一个私有共享内存段，或使用ftok()函数根据文件路径生成一个唯一的键值。
    • size_t size：共享内存的大小，以字节为单位。
    • int shmflg：标志位，用于控制创建和获取共享内存的行为。
      • IPC_CREAT：如果指定的共享内存不存在，则创建它；如果已存在，则返回其标识符。
      • IPC_EXCL：与IPC_CREAT一起使用时，如果共享内存已存在，则调用失败（返回-1）。
  • 返回值：成功时返回共享内存的标识符（一个非负整数），失败时返回-1。

ftok函数是用于生成一个唯一的键值（key）的函数，通常用于创建共享内存、消息队列等进程间通信的标识符。它的原型是：

参数说明：

  1. const char *pathname：一个文件路径名字符串，它应该指向一个已存在的文件。
  2. int proj_id：一个非负整数，用于与pathname一起生成唯一的键值。

ftok函数会返回一个唯一的键值，如果发生错误则返回-1。这个键值可以用于后续的shmget等系统调用中，以标识和引用特定的共享内存段。

        这意味着，我们给两个进程使用同样的pathname和同样的id，调用同样的ftok，就能形成同样的key了。通过同样的key，就是能看到同一份资源的必要条件。

共享内存是需要手动释放的，不随着进程的结束而结束

ipcs -m查共享内存，ipcrm -m删除共享内存（按照共享内存的shmid删除）

当然你也可以使用函数shmctl

参数说明

  • shmid：共享内存标识符，即要控制的共享内存段的标识符，通常由 shmget 函数返回。
  • cmd：控制命令，用于指定要执行的操作。常用的命令包括：
    • IPC_RMID：删除共享内存段。
    • IPC_SET：设置共享内存段的权限和所有者。
    • IPC_STAT：获取共享内存段的状态信息。
  • buf：指向 struct shmid_ds 结构的指针，用于存储共享内存段的信息或设置其属性。可以为 NULL，表示不获取或设置共享内存段的信息。

返回值

如果函数执行成功，返回值为 0；如果出现错误，返回值为 -1，并设置 errno 来指示具体的错误原因。

key vs shmid

key：属于用户形成，内核使用的一个字段，用户不能使用key来进行shm的管理，是给内核用来区分shm唯一性的（用户给操作系统用的）

shmid：内核给用户返回的一个标识符，让用户对shm进行管理的id值（操作系统给用户的）

        使用共享内存标识符而不是键进行后续操作也增加了安全性。因为即使其他进程知道了你的共享内存段的键，它们也无法直接访问或修改你的共享内存段，除非它们也通过shmget获取了对应的共享内存标识符，并且有足够的权限来操作这个共享内存段。

使用共享内存时要挂接，这时就要用到一个函数shmat。

hmat函数在Linux系统编程中用于将进程挂接到共享内存上，从而实现不同进程间的通信。以下是关于shmat函数的详细解释：

1. 函数原型

2. 参数说明

  • shmid：由shmget函数返回的共享内存标识符。
  • shmaddr：指定共享内存连接到当前进程时的地址。有三种情况：
    • 如果shmaddr是NULL，系统将自动选择一个合适的地址。
    • 如果shmaddr不是NULL并且没有指定SHM_RND，则此段连接到addr所指定的地址上。
    • 如果shmaddr非0并且指定了SHM_RND，则此段连接到shmaddr - (shmaddr mod SHMLAB)所表示的地址上，其中SHMLAB是低边界地址的倍数，它总是2的乘方。
  • shmflg：是一组按位OR（或）在一起的标志，用来控制读写权限等。其两个可能取值是SHM_RND和SHM_RDONLY。如果指定了SHM_RDONLY，则以只读方式连接此段，否则以读写的方式连接此段。

3. 返回值

  • 如果调用成功，返回一个指向共享内存的指针。
  • 如果出错，返回-1。

4. 原理

shmat函数从进程空间中选择一个合适的或者用户指定的线性地址，并将其挂接到共享内存的物理页上。一旦挂接完成，用户就可以通过返回的指针来访问共享内存中的数据。

5. 注意事项

  • 在使用shmdt函数断开线性地址到物理地址的映射关系后，不能再次使用shmat函数进行挂接，否则可能会导致segment fault。
  • 共享内存是IPC（进程间通信）中效率最高的方式之一，因为它允许进程直接访问内存中的数据，而不需要像管道、消息队列那样进行内核与用户空间的数据拷贝。

shmdt 的基本使用：用于从共享内存段中分离一个进程

  • shmaddr：这是指向共享内存段的指针，该指针是之前通过 shmat 系统调用返回的。

返回值：

  • 如果成功，返回 0。
  • 如果失败，返回 -1 并设置 errno 以指示错误。

使用 shmdt 时，要注意以下几点：

  1. 只影响当前进程：调用 shmdt 只影响当前进程。其他已经附加到该共享内存段的进程仍然可以访问它。
  2. 数据持久性：即使调用了 shmdt，共享内存段中的数据仍然保持不变，直到所有进程都与其分离，或者调用者（通常是创建该段的进程）显式地删除了它（使用 shmctl 系统调用和 IPC_RMID 命令）。
  3. 多次附加和分离：一个进程可以多次使用 shmat 附加到同一个共享内存段，并可以多次使用 shmdt 分离。但每次附加都需要一个单独的分离操作。
  4. 关闭文件描述符：如果在附加共享内存时创建了一个文件描述符（例如，使用 O_CREAT | O_RDWR 标志调用 shmat），则在调用 shmdt 后，应使用 close 系统调用来关闭该文件描述符。但请注意，这不会影响其他进程对共享内存段的访问。
  5. 错误处理：如果 shmdt 调用失败，应检查 errno 以了解失败的原因。可能的错误包括 EINVAL（无效的 shmaddr 参数）和 EACCES（调用进程没有足够的权限来分离该共享内存段）。

3.使用一下shmget（一段代码） 

创建方法：

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cerrno>
  6. #include <cstdio>
  7. #include <cstring>
  8. #include <sys/ipc.h>
  9. #include <sys/shm.h>
  10. #include <unistd.h>
  11.  
  12. //用当前路径形成key值
  13. const std::string gpathname = "/home/ubuntu/work/shm";
  14. //随意设置一个
  15. const int gproj_id = 0x66;
  16. //将key转为16进制
  17. std::string ToHex(key_t k)
  18. {
  19.     char buffer[128];
  20.     snprintf(buffer,zizeof(buffer),"0x%x",k);
  21. }
  22.  
  23.     //形成相同的key值
  24.     key_t GetCommKey(const std::string &gpathname,int gproj_id)
  25.     {
  26.         key_t k = ftok(_pathname.c_str(), _proj_id);
  27.         if (k < 0)
  28.         {
  29.             perror("ftok");
  30.         }
  31.         return k;
  32.     }
  33.     //创建shm
  34.     int ShmGet(key_t key,int size)
  35.     {
  36.         int shmid =shmget(key,size,IPC_CREAT | IPC_EXCL);
  37.         if(shmid<0)
  38.         {
  39.             perror("shmget");
  40.         }
  41.  
  42.         return shmid;
  43.     }

服务端创建：

  1. #include "Shm.hpp"
  2.  
  3. int main()
  4. {   
  5.     key_t key=GetCommKey(gpathname,gproj_id);
  6.     std::cout<<"key:"<<ToHex(key)<<std::endl;
  7.  
  8.     int shmid=ShmGet(key,4096);
  9.     std::cout<<"shmid:"<<shmid<<std::endl;
  10.  
  11.     return 0;
  12. }

客户端：

  1. #include "Shm.hpp"
  2.  
  3. int main()
  4. {
  5.     key_t key=GetCommKey(gpathname,gproj_id);
  6.     std::cout<<"key:"<<ToHex(key)<<std::endl;
  7.  
  8.     return 0;
  9. }

运行结果：有相同的key，

4.一个案例（一段代码)

1.简单封装一下

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <cerrno>
  5. #include <cstdio>
  6. #include <cstring>
  7. #include <sys/ipc.h>
  8. #include <sys/shm.h>
  9. #include <unistd.h>
  10.  
  11. const int gCreater = 1;
  12. const int gUser = 2;
  13. //用当前路径形成key值
  14. const std::string gpathname = "/home/ubuntu/work/shm";
  15. //随意设置一个
  16. const int gproj_id = 0x66;
  17. //将key转为16进制
  18. const int gShmSize = 4097;
  19. class Shm
  20. {
  21. private:
  22.     key_t GetCommKey()
  23.     {
  24.         key_t k = ftok(_pathname.c_str(), _proj_id);
  25.         if (k < 0)
  26.         {
  27.             perror("ftok");
  28.         }
  29.         return k;
  30.     }
  31.     int GetShmHelper(key_t key, int size, int flag)
  32.     {
  33.         int shmid = shmget(key, size, flag);
  34.         if (shmid < 0)
  35.         {
  36.             perror("shmget");
  37.         }
  38.  
  39.         return shmid;
  40.     }
  41. public:
  42.     Shm(const std::string &pathname, int proj_id, int who)
  43.         : _pathname(pathname), _proj_id(proj_id), _who(who)
  44.     {
  45.         _key = GetCommKey();
  46.         if (_who == gCreater)
  47.             GetShmUseCreate();
  48.         else if (_who == gUser)
  49.             GetShmForUse();
  50.         std::cout << "shmid: " << _shmid << std::endl;
  51.         std::cout << "_key: " << ToHex(_key) << std::endl;
  52.     }
  53.     ~Shm()
  54.     {
  55.         if (_who == gCreater)
  56.         {
  57.             int res = shmctl(_shmid, IPC_RMID, nullptr);
  58.         }
  59.         std::cout << "shm remove done..." << std::endl;
  60.     }
  61.  
  62.     std::string ToHex(key_t key)
  63.     {
  64.         char buffer[128];
  65.         snprintf(buffer, sizeof(buffer), "0x%x", key);
  66.         return buffer;
  67.     }
  68.     bool GetShmUseCreate()
  69.     {
  70.         if (_who == gCreater)
  71.         {
  72.             _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL);
  73.             if (_shmid >= 0)
  74.                 return true;
  75.             std::cout << "shm create done..." << std::endl;
  76.         }
  77.         return false;
  78.     }
  79.     bool GetShmForUse()
  80.     {
  81.         if (_who == gUser)
  82.         {
  83.             _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT);
  84.             if (_shmid >= 0)
  85.                 return true;
  86.             std::cout << "shm get done..." << std::endl;
  87.         }
  88.         return false;
  89.     }
  90. private:
  91. private:
  92.     key_t _key;
  93.     int _shmid;
  94.  
  95.     std::string _pathname;
  96.     int _proj_id;
  97.     //我是谁
  98.     int _who;
  99. };

服务段：

  1. #include "Shm.hpp"
  2.  
  3. int main()
  4. {
  5.     Shm shm(gpathname,gproj_id,gCreater);
  6.     return 0;
  7. }

用户段：

  1. #include "Shm.hpp"
  2.  
  3. int main()
  4. {
  5.     Shm shm(gpathname,gproj_id,gUser);
  6.     return 0;
  7. }

运行结果：

2.使用共享内存

 2.1挂接（shmat）和取消挂接（shmdt）

现阶段，我们只是让进程A和B看到了共享内存，使用共享内存的前提是要，将共享内存挂接（使用函数shmat）进程的地址空间上。进程可以将之前创建的共享内存区域映射到自己的虚拟地址空间中。这样，进程就可以通过指针直接访问这块共享内存，而无需通过内核进行数据的拷贝。在使用这个函数的时候，是要访问共享内存的，共享内存也是文件，当然也有权限，因此我们创建共享内存的时候是要带权限的。

_shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL | 0666);

         当多个进程都映射了同一块共享内存到各自的地址空间后 ，进程A可以将数据写入共享内存，然后进程B可以从共享内存中读取这些数据，从而实现进程间的数据交换。

        当你不再需要这块共享内存，或者你的进程即将结束时，你应该使用 shmdt 来从这块内存中分离。这样做可以确保系统能够正确地管理这块内存，防止资源泄露。

  1.     void *AttachShm()
  2.     {
  3.         if (_addrshm != nullptr)
  4.             DetachShm(_addrshm);
  5.         void *shmaddr = shmat(_shmid, nullptr, 0);
  6.         if (shmaddr == nullptr)
  7.         {
  8.             perror("shmat");
  9.         }
  10.         std::cout << "who: " << RoleToString(_who) << " attach shm..." << std::endl;
  11.         return shmaddr;
  12.     }
  13.     void DetachShm(void *shmaddr)
  14.     {
  15.         if (shmaddr == nullptr)
  16.             return;
  17.         shmdt(shmaddr);
  18.         std::cout << "who: " << RoleToString(_who) << " detach shm..." << std::endl;
  19.     }

2.2重新封装

这里我们新增了一个成员变量，addshm，用于记录共享内存的地址。

在向共享内存中写东西之前，我们先做清空，这里我们多加一个操作函数。

  1.     void Zero()
  2.     {
  3.         if(_addrshm)
  4.         {
  5.             memset(_addrshm, 0, gShmSize);
  6.         }
  7.     }

重新封装后：

  1. ​
  2. #include <iostream>
  3. #include <string>
  4. #include <cerrno>
  5. #include <cstdio>
  6. #include <cstring>
  7. #include <sys/ipc.h>
  8. #include <sys/shm.h>
  9. #include <unistd.h>
  10.  
  11. const int gCreater = 1;
  12. const int gUser = 2;
  13. const std::string gpathname = "/home/whb/code/111/code/lesson22/4.shm";
  14. const int gproj_id = 0x66;
  15. const int gShmSize = 4097; // 4096*n
  16.  
  17. class Shm
  18. {
  19. private:
  20.     key_t GetCommKey()
  21.     {
  22.         key_t k = ftok(_pathname.c_str(), _proj_id);
  23.         if (k < 0)
  24.         {
  25.             perror("ftok");
  26.         }
  27.         return k;
  28.     }
  29.     int GetShmHelper(key_t key, int size, int flag)
  30.     {
  31.         int shmid = shmget(key, size, flag);
  32.         if (shmid < 0)
  33.         {
  34.             perror("shmget");
  35.         }
  36.  
  37.         return shmid;
  38.     }
  39.     std::string RoleToString(int who)
  40.     {
  41.         if (who == gCreater)
  42.             return "Creater";
  43.         else if (who == gUser)
  44.             return "gUser";
  45.         else
  46.             return "None";
  47.     }
  48.     void *AttachShm()
  49.     {
  50.         if (_addrshm != nullptr)
  51.             DetachShm(_addrshm);
  52.         void *shmaddr = shmat(_shmid, nullptr, 0);
  53.         if (shmaddr == nullptr)
  54.         {
  55.             perror("shmat");
  56.         }
  57.         std::cout << "who: " << RoleToString(_who) << " attach shm..." << std::endl;
  58.         return shmaddr;
  59.     }
  60.     void DetachShm(void *shmaddr)
  61.     {
  62.         if (shmaddr == nullptr)
  63.             return;
  64.         shmdt(shmaddr);
  65.         std::cout << "who: " << RoleToString(_who) << " detach shm..." << std::endl;
  66.     }
  67.  
  68. public:
  69.     Shm(const std::string &pathname, int proj_id, int who)
  70.         : _pathname(pathname), _proj_id(proj_id), _who(who), _addrshm(nullptr)
  71.     {
  72.         _key = GetCommKey();
  73.         if (_who == gCreater)
  74.             GetShmUseCreate();
  75.         else if (_who == gUser)
  76.             GetShmForUse();
  77.         _addrshm = AttachShm();
  78.  
  79.         std::cout << "shmid: " << _shmid << std::endl;
  80.         std::cout << "_key: " << ToHex(_key) << std::endl;
  81.     }
  82.     ~Shm()
  83.     {
  84.         if (_who == gCreater)
  85.         {
  86.             int res = shmctl(_shmid, IPC_RMID, nullptr);
  87.         }
  88.         std::cout << "shm remove done..." << std::endl;
  89.     }
  90.  
  91.     std::string ToHex(key_t key)
  92.     {
  93.         char buffer[128];
  94.         snprintf(buffer, sizeof(buffer), "0x%x", key);
  95.         return buffer;
  96.     }
  97.     bool GetShmUseCreate()
  98.     {
  99.         if (_who == gCreater)
  100.         {
  101.             _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL | 0666);
  102.             if (_shmid >= 0)
  103.                 return true;
  104.             std::cout << "shm create done..." << std::endl;
  105.         }
  106.         return false;
  107.     }
  108.     bool GetShmForUse()
  109.     {
  110.         if (_who == gUser)
  111.         {
  112.             _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | 0666);
  113.             if (_shmid >= 0)
  114.                 return true;
  115.             std::cout << "shm get done..." << std::endl;
  116.         }
  117.         return false;
  118.     }
  119.     void Zero()
  120.     {
  121.         if(_addrshm)
  122.         {
  123.             memset(_addrshm, 0, gShmSize);
  124.         }
  125.     }
  126.  
  127.     void *Addr()
  128.     {
  129.         return _addrshm;
  130.     }
  131.  
  132.  
  133.  
  134. private:
  135.     key_t _key;
  136.     int _shmid;
  137.  
  138.     std::string _pathname;
  139.     int _proj_id;
  140.  
  141.     int _who;
  142.     void *_addrshm;
  143. };
  144.  
  145. ​

2.3使用共享内存进行通信

server作为读端

  1. int main()
  2. {
  3.     //读端
  4.     Shm shm(gpathname,gproj_id,gCreater);
  5.     char *shmaddr =(char*)shm.Addr();
  6.  
  7.     //读内容
  8.     while(true)
  9.     {
  10.         std::cout<<"shm memory content:"<<shmaddr<<std::endl;
  11.         sleep(1);
  12.     }
  13.     return 0;
  14. }

client作为写端

  1. int main()
  2. {
  3.     //写端
  4.   
  5.     Shm shm(gpathname,gproj_id,gUser);
  6.     shm.Zero();
  7.     char *shmaddr = (char*)shm.Addr();
  8.  
  9.     //写内容
  10.     char ch='A';
  11.     while(ch<='Z')
  12.     {
  13.         shmaddr[ch-'A'] =ch;
  14.         ch++;
  15.         sleep(2);
  16.     }
  17.     return 0;
  18. }

运行结果：

 5.共享内存的优劣

以下是对其优缺点的详细分析：

优点：

  1. 高效性：
    • 共享内存是IPC通信中传输速度最快的通信方式。因为数据不需要在客户机和服务器之间复制，数据直接写到内存，避免了多次数据拷贝，从而大大提高了通信效率。
    • 进程对共享内存的访问就如同访问自己的内存空间一样，不需要进行额外的系统调用或内核操作，进一步提升了效率。
  2. 灵活性：
    • 允许多个进程共享数据，提供了一种灵活的通信方式。
    • 进程间可以通过共享的内存区域进行双向通信，满足了多种通信需求。
  3. 支持大量数据传输：
    • 适用于需要快速传递大量数据的场景，特别是在大数据处理、实时通信等领域表现突出。

缺点：

  1. 同步问题：
    • 由于多个进程可以同时访问共享内存，需要额外的同步机制来避免数据竞争和一致性问题。内核并不提供任何对共享内存访问的同步机制，因此通常需要使用信号量等其他IPC机制进行读写同步与互斥。（写端没写，读端不会阻塞等待，依旧进行读取）
  2. 安全性：
    • 需要额外的安全机制来保护数据，防止其他进程非法访问。若未采取适当的安全措施，可能导致数据泄露或被篡改。
  3. 编程复杂性：
    • 使用共享内存进行通信需要处理同步和数据一致性等复杂问题，编程复杂度较高。需要开发者具备深厚的操作系统和并发编程知识。
  4. 依赖操作系统支持：
    • 共享内存的使用依赖于操作系统的支持。不同的操作系统或版本可能对共享内存的实现和管理方式存在差异，这增加了跨平台开发的难度。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/703736
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号