【Linux】System V 共享内存

共享内存区是最快的 IPC 形式。一旦如许的内存映射到共享它的历程的地址空间，这些历程间数据传递不再涉及到内核，换句话说是历程不再通过执行进入内核的系统调用来传递相互的数据。
1. 共享内存表示图

2. 共享内存数据结构

1. struct shmid_ds
2. {
3.     struct ipc_perm shm_perm;    /* operation perms */
4.     int shm_segsz;               /* size of segment (bytes) */
5.     __kernel_time_t shm_atime;   /* last attach time */
6.     __kernel_time_t shm_dtime;   /* last detach time */
7.     __kernel_time_t shm_ctime;   /* last change time */
8.     __kernel_ipc_pid_t shm_cpid; /* pid of creator */
9.     __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
10.     unsigned short shm_nattch;   /* no. of current attaches */
11.     unsigned short shm_unused;   /* compatibility */
12.     void *shm_unused2;           /* ditto - used by DIPC */
13.     void *shm_unused3;           /* unused */
14. };

复制代码

3. 共享内存函数

shmget

1. 功能：用来创建共享内存
2. 原型
3.         int shmget(key_t key, size_t size, int shmflg);
4. 参数
5.         key：这个共享内存段名字
6.         size：共享内存大小
7.         shmflg：由九个权限标志构成，它们的用法和创建文件时使用的 mode 模式标志是一样的
8. 返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

复制代码

shmat

1. 功能：将共享内存段连接到进程地址空间
2. 原型
3.         void* shmat(int shmid, const void* shmaddr, int shmflg);
4. 参数
5.         shmid：共享内存标识
6.         shmaddr：指定连接的地址
7.         shmflg：它的两个可能取值是 SHM_RND 和 SHM_RDONLY
8. 返回值：成功返回一个指针，指向共享内存的地址；失败返回-1

复制代码

• 说明：
  

1. shmaddr 为 NULL，核心自动选择一个地址。
2. shmaddr 不为 NULL 且 shmflg 无 SHM_RND 标记，则以 shmaddr 为连接地址。
3. shmaddr 不为 NULL 且 shmflg 设置了 SHM_RND 标记，则连接的地址会自动向下调整为 SHMLBA 的整数倍；
4.         公式：shmaddr - (shmaddr % SHMLBA)。
5. shmflg = SHM_RDONLY，表示连接操作用来只读共享内存。

复制代码

shmdt

1. 功能：将共享内存段与当前进程脱离
2. 原型
3.         int shmdt(const void* shmaddr);
4. 参数
5.         shmaddr：由 shmat 所返回的指针
6. 返回值：成功返回0；失败返回-1
7. 注意：将共享内存段与当前进程脱离不等于删除共享内存段

复制代码

shmctl

1. 功能：用于控制共享内存
2. 原型
3.         int shmctl(int shmid, int cmd, struct shmid_ds* buf);
4. 参数
5.         shmid：由 shmget 返回的共享内存标识码
6.         cmd：将要采取的动作（有三个可取值）
7.         buf：指向一个保存着共享内存的模式状态和访问权限的数据结构
8. 返回值：成功返回0；失败返回-1

复制代码

4. 实例代码测试共享内存

• 利用共享内存通讯，一定是一个历程创建新的 shm，另一个直接获取共享内存即可。
  

代码结构：

1. $ ls
2. Comm.hpp  Fifo.hpp  Makefile  ShmClient.cc  ShmServer.cc
4. $ cat Makefile
5. .PHONY:all
6. all:shm_client shm_server
8. shm_server:ShmServer.cc
9.         g++ -o $@ $^ -std=c++11
10. shm_client:ShmClient.cc
11.         g++ -o $@ $^ -std=c++11
13. .PHONY:clean
14. clean:
15.         rm -f shm_client shm_server

复制代码

Fifo.hpp：

1. #ifndef __COMM_HPP__
2. #define __COMM_HPP__
4. #include <iostream>
5. #include <string>
6. #include <cerrno>
7. #include <cstring>
8. #include <sys/types.h>
9. #include <sys/stat.h>
10. #include <unistd.h>
11. #include <fcntl.h>
12. #include <cassert>
14. using namespace std;
16. #define Mode 0666
17. #define Path "./fifo"
19. class Fifo
20. {
21. public:
22.     Fifo(const string &path = Path)
23.         : _path(path)
24.     {
25.         umask(0);
26.         int n = mkfifo(_path.c_str(), Mode);
27.         if (n == 0)
28.         {
29.             cout << "mkfifo success" << endl;
30.         }
31.         else
32.         {
33.             cerr << "mkfifo failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
34.         }
35.     }
37.     ~Fifo()
38.     {
39.         int n = unlink(_path.c_str());
40.         if (n == 0)
41.         {
42.             cout << "remove fifo file " << _path << " success" << endl;
43.         }
44.         else
45.         {
46.             cerr << "remove failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
47.         }
48.     }
50. private:
51.     string _path; // 文件路径 + 文件名
52. };
54. class Sync
55. {
56. public:
57.     Sync()
58.         : rfd(-1), wfd(-1)
59.     {
60.     }
62.     void OpenReadOrDie()
63.     {
64.         rfd = open(Path, O_RDONLY);
65.         if (rfd < 0)
66.             exit(1);
67.     }
69.     void OpenWriteOrDie()
70.     {
71.         wfd = open(Path, O_WRONLY);
72.         if (wfd < 0)
73.             exit(1);
74.     }
76.     bool Wait()
77.     {
78.         bool ret = true;
79.         uint32_t c = 0;
80.         ssize_t n = read(rfd, &c, sizeof(uint32_t));
81.         if (n == sizeof(uint32_t))
82.         {
83.             std::cout << "server wakeup, begin read shm..." << std::endl;
84.         }
85.         else if (n == 0)
86.         {
87.             ret = false;
88.         }
89.         else
90.         {
91.             return false;
92.         }
93.         return ret;
94.     }
96.     void Wakeup()
97.     {
98.         uint32_t c = 0;
99.         ssize_t n = write(wfd, &c, sizeof(c));
100.         assert(n == sizeof(uint32_t));
102.         std::cout << "wakeup server..." << std::endl;
103.     }
105.     ~Sync()
106.     {
107.     }
109. private:
110.     int rfd;
111.     int wfd;
112. };
114. #endif

复制代码

Comm.hpp：

1. #pragma once
3. #include <iostream>
4. #include <cerrno>
5. #include <cstring>
6. #include <cstdlib>
7. #include <string>
8. #include <sys/ipc.h>
9. #include <sys/shm.h>
10. #include <sys/types.h>
12. using namespace std;
14. const char *pathname = "/home/ubuntu";
15. const int proj_id = 0x66;
17. // 在内核中，共享内存的大小是以4KB为基本单位的，你只能用你申请的大小。建议申请大小是N*4KB
18. const int defaultsize = 4096; // 单位是字节
20. std::string ToHex(key_t k)
21. {
22.     char buffer[1024];
23.     snprintf(buffer, sizeof(buffer), "0x%x", k);
24.     return buffer;
25. }
27. key_t GetShmKeyOrDie()
28. {
29.     key_t k = ftok(pathname, proj_id);
30.     if (k < 0)
31.     {
32.         std::cerr << "ftok error, errno: " << errno << ", error string: " << strerror(errno) << std::endl;
33.         exit(1);
34.     }
35.     return k;
36. }
38. int CreateShmOrDie(key_t key, int size, int flag)
39. {
40.     int shmid = shmget(key, size, flag);
41.     if (shmid < 0)
42.     {
43.         std::cerr << "shmget error, errno: " << errno << ", error string: " << strerror(errno) << std::endl;
44.         exit(2);
45.     }
46.     return shmid;
47. }
49. int CreateShm(key_t key, int size)
50. {
51.     // IPC_CREAT: 不存在就创建，存在就获取
52.     // IPC_EXCL: 没有意义
53.     // IPC_CREAT | IPC_EXCL: 不存在就创建，存在就出错返回
54.     return CreateShmOrDie(key, size, IPC_CREAT | 0666);
55. }
57. int GetShm(key_t key, int size)
58. {
59.     return CreateShmOrDie(key, size, IPC_CREAT);
60. }
62. void DeleteShm(int shmid)
63. {
64.     int n = shmctl(shmid, IPC_RMID, nullptr);
65.     if (n < 0)
66.     {
67.         std::cerr << "shmctl error" << std::endl;
68.     }
69.     else
70.     {
71.         std::cout << "shmctl delete shm success, shmid: " << shmid << std::endl;
72.     }
73. }
75. void ShmDebug(int shmid)
76. {
77.     struct shmid_ds shmds;
78.     int n = shmctl(shmid, IPC_STAT, &shmds);
79.     if (n < 0)
80.     {
81.         std::cerr << "shmctl error" << std::endl;
82.         return;
83.     }
84.     std::cout << "shmds.shm_segez: " << shmds.shm_segsz << std::endl;
85.     std::cout << "shmds.shm_nattch: " << shmds.shm_nattch << std::endl;
86.     std::cout << "shmds.shm_ctime: " << shmds.shm_ctime << std::endl;
87.     std::cout << "shmds.shm_perm.__key: " << ToHex(shmds.shm_perm.__key) << std::endl;
88. }
90. void *ShmAttach(int shmid)
91. {
92.     // 核心自动选择一个地址
93.     void *addr = shmat(shmid, nullptr, 0);
94.     if ((long long int)addr == -1)
95.     {
96.         std::cerr << "shmat error" << std::endl;
97.         return nullptr;
98.     }
99.     return addr;
100. }
102. void ShmDetach(void *addr)
103. {
104.     int n = shmdt(addr);
105.     if (n < 0)
106.     {
107.         std::cerr << "shmdt error" << std::endl;
108.     }
109. }

复制代码

ShmServer：

1. #include "Comm.hpp"
2. #include "Fifo.hpp"
4. int main()
5. {
6.     // 1. 获取key
7.     key_t key = GetShmKeyOrDie();
8.     std::cout << "key: " << ToHex(key) << std::endl;
10.     // 2. 创建共享内存
11.     int shmid = CreateShm(key, defaultsize);
12.     std::cout << "shmid: " << shmid << std::endl;
14.     // 4. 将共享内存和进程进行挂接（关联）
15.     char *addr = (char *)ShmAttach(shmid);
16.     std::cout << "Attach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;
18.     // 0. 先引入管道
19.     Fifo fifo;
20.     Sync syn;
21.     syn.OpenReadOrDie();
23.     // 可以进行通信了
24.     for (;;)
25.     {
26.         if (!syn.Wait())
27.             break;
28.         std::cout << "shm content: " << addr << std::endl;
29.     }
31.     ShmDetach(addr);
32.     std::cout << "Detach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;
34.     // 3. 删除共享内存
35.     DeleteShm(shmid);
37.     return 0;
38. }

复制代码

ShmClient：

1. #include "Comm.hpp"
2. #include "Fifo.hpp"
4. int main()
5. {
6.     key_t key = GetShmKeyOrDie();
7.     std::cout << "key: " << ToHex(key) << std::endl;
9.     int shmid = GetShm(key, defaultsize);
10.     std::cout << "shmid: " << shmid << std::endl;
12.     char *addr = (char *)ShmAttach(shmid);
13.     std::cout << "Attach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;
15.     memset(addr, 0, defaultsize);
16.     Sync syn;
17.     syn.OpenWriteOrDie();
19.     // 可以进行通信了
20.     for (char c = 'A'; c <= 'Z'; c++) // shm没有使用系统调用
21.     {
22.         addr[c - 'A'] = c;
23.         syn.Wakeup();
24.         sleep(1);
25.     }
27.     ShmDetach(addr);
28.     std::cout << "Detach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;
29.     sleep(5);
31.     return 0;
32. }

复制代码

结果演示：

5. 共享内存相关命令

• 共享内存，如果历程结束，我们没有自动开释它，则共享内存一直存在。
  
• 共享内存的生命周期是随内核的，只有重启系统它才会自行销毁。
  
• 为了更好地控制共享内存，我们要会利用命令删除它。
  
• 不管是指令还是代码，想对共享内存举行控制，都必要利用 shmid ，shmid 是共享内存的唯一性标识！
  

1. # 查看共享内存
2. ipcs -m
4. # 删除指定共享内存
5. ipcrm -m [shmid]

复制代码

1. # 实机演示
2. $ ipcs -m
4. ------ Shared Memory Segments --------
5. key        shmid      owner      perms      bytes      nattch     status      
6. 0x00000000 0          root       644        80         2                       
7. 0x00000000 1          root       644        16384      2                       
8. 0x00000000 2          root       644        280        2                       
9. 0x6602fc97 10         ubuntu     666        4096       1
11. $ ipcrm -m 10        # 指定shmid即可删除该共享内存资源

复制代码

留意：不是必须通过手动来删除，这里只是为了演示相关指令，删除共享内存资源是历程该做的变乱。
留意：共享内存没有历程同步与互斥！
6. System V 消息队列（了解）

• 消息队列提供了从一个历程向另外一个历程发送一块数据的方法。
  
• 每个数据块都被认为是有一个范例，接收者历程接收的数据块可以有差异的范例值。
  
• IPC 资源必须删除，否则不会自动清除，除非重启，以是 System V IPC 资源的生命周期随内核。
  

7. System V 信号量（了解）

• 信号量重要用于同步和互斥。
  
• 由于各历程要求共享资源，而且有些资源必要互斥利用，因此各历程间竞争利用这些资源，历程的这种关系为历程的互斥。
  
• 系统中某些资源一次只允许一个历程利用，称如许的资源为临界资源或互斥资源。
  
• 在历程中涉及到互斥资源的步伐段叫临界区。
  

---

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