进程间通信——共享内存（Shared Memory）

共享内存是System V版本的最后一个进程间通信方式。共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。

特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取，所以我们通常需要用其他的机制来同步对共享内存的访问，例如信号量。

下面就 Shared Memory 的IPC作以阐述与分析。

共享内存的通信原理

在Linux中，每个进程都有属于自己的进程控制块（PCB）和地址空间（Addr Space），并且都有一个与之对应的页表，负责将进程的虚拟地址与物理地址进行映射，通过内存管理单元（MMU）进行管理。两个不同的虚拟地址通过页表映射到物理空间的同一区域，它们所指向的这块区域即共享内存。

共享内存的通信原理示意图：

对于上图我的理解是：当两个进程通过页表将虚拟地址映射到物理地址时，在物理地址中有一块共同的内存区，即共享内存，这块内存可以被两个进程同时看到。这样当一个进程进行写操作，另一个进程读操作就可以实现进程间通信。但是，我们要确保一个进程在写的时候不能被读，因此我们使用信号量来实现同步与互斥。

对于一个共享内存，实现采用的是引用计数的原理，当进程脱离共享存储区后，计数器减一，挂架成功时，计数器加一，只有当计数器变为零时，才能被删除。当进程终止时，它所附加的共享存储区都会自动脱离。

为什么共享内存速度最快？

借助上图说明：Proc A 进程给内存中写数据， Proc B 进程从内存中读取数据，在此期间一共发生了两次复制

（1）Proc A 到共享内存       （2）共享内存到 Proc B

因为直接在内存上操作，所以共享内存的速度也就提高了。

共享内存的接口函数以及指令

1.查看系统中的共享存储段

ipcs -m

2.删除系统中的共享存储段

ipcrm -m [shmid]

3.shmget ( )：创建共享内存

int shmget(key_t key, size_t size, int shmflg);

[参数key]：由ftok生成的key标识，标识系统的唯一IPC资源。

[参数size]：需要申请共享内存的大小。在操作系统中，申请内存的最小单位为页，一页是4k字节，为了避免内存碎片，我们一般申请的内存大小为页的整数倍。

[参数shmflg]：如果要创建新的共享内存，需要使用IPC_CREAT，IPC_EXCL，如果是已经存在的，可以使用IPC_CREAT或直接传0。

[返回值]：成功时返回一个新建或已经存在的的共享内存标识符，取决于shmflg的参数。失败返回-1并设置错误码。

4.shmat ( )：挂接共享内存

void *shmat(int shmid, const void *shmaddr, int shmflg);

[参数shmid]：共享存储段的标识符。

[参数*shmaddr]：shmaddr = 0，则存储段连接到由内核选择的第一个可以地址上（推荐使用）。

[参数shmflg]：若指定了SHM_RDONLY位，则以只读方式连接此段，否则以读写方式连接此段。

[返回值]：成功返回共享存储段的指针（虚拟地址），并且内核将使其与该共享存储段相关的shmid_ds结构中的shm_nattch计数器加1（类似于引用计数）；出错返回-1。

5.shmdt ( )：去关联共享内存

当一个进程不需要共享内存的时候，就需要去关联。该函数并不删除所指定的共享内存区，而是将之前用shmat函数连接好的共享内存区脱离目前的进程。

int shmdt(const void *shmaddr);

[参数*shmaddr]：连接以后返回的地址。

[返回值]：成功返回0，并将shmid_ds结构体中的 shm_nattch计数器减1；出错返回-1。

6.shmctl ( )：销毁共享内存

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

[参数shmid]：共享存储段标识符。

[参数cmd]：指定的执行操作，设置为IPC_RMID时表示可以删除共享内存。

[参数*buf]：设置为NULL即可。

[返回值]：成功返回0，失败返回-1。

模拟共享内存

我们用server来创建共享存储段，用client获取共享存储段的标识符，二者关联起来之后server将数据写入共享存储段，client从共享区读取数据。通信结束之后server与client断开与共享区的关联，并由server释放共享存储段。

comm.h

1. //comm.h

2. #ifndef _COMM_H__

3. #define _COMM_H__

4.  

5. #include

6. #include

7. #include

8. #include

9.  

10. #define PATHNAME "."

11. #define PROJ_ID 0x6666

12.  

13. int CreateShm(int size);

14. int DestroyShm(int shmid);

15. int GetShm(int size);

16. #endif

comm.c

1. //comm.c

2. #include"comm.h"

3.  

4. static int CommShm(int size,int flags)

5. {

6. key_t key = ftok(PATHNAME,PROJ_ID);

7. if(key < 0)

8. {

9. perror("ftok");

10. return -1;

11. }

12. int shmid = 0;

13. if((shmid = shmget(key,size,flags)) < 0)

14. {

15. perror("shmget");

16. return -2;

17. }

18. return shmid;

19. }

20. int DestroyShm(int shmid)

21. {

22. if(shmctl(shmid,IPC_RMID,NULL) < 0)

23. {

24. perror("shmctl");

25. return -1;

26. }

27. return 0;

28. }

29. int CreateShm(int size)

30. {

31. return CommShm(size,IPC_CREAT | IPC_EXCL | 0666);

32. }

33. int GetShm(int size)

34. {

35. return CommShm(size,IPC_CREAT);

36. }

client.c

1. //client.c

2. #include"comm.h"

3.  

4. int main()

5. {

6. int shmid = GetShm(4096);

7. sleep(1);

8. char *addr = shmat(shmid,NULL,0);

9. sleep(2);

10. int i = 0;

11. while(i < 26)

12. {

13. addr[i] = 'A' + i;

14. i++;

15. addr[i] = 0;

16. sleep(1);

17. }

18. shmdt(addr);

19. sleep(2);

20. return 0;

21. }

server.c

1. //server.c

2. #include"comm.h"

3.  

4. int main()

5. {

6. int shmid = CreateShm(4096);

7.  

8. char *addr = shmat(shmid,NULL,0);

9. sleep(2);

10. int i = 0;

11. while(i++ < 26)

12. {

13. printf("client# %s\n",addr);

14. sleep(1);

15. }

16. shmdt(addr);

17. sleep(2);

18. DestroyShm(shmid);

19. return 0;

20. }

Makefile

1. //Makefile

2. .PHONY:all

3. all:server client

4.  

5. client:client.c comm.c

6. gcc -o $@ $^

7. server:server.c comm.c

8. gcc -o $@ $^

9.  

10. .PHONY:clean

11. clean:

12. rm -f client server

运行结果：

总结：

（1）优点：我们可以看到使用共享内存进行进程之间的通信是非常方便的，而且函数的接口也比较简单，数据的共享还使进程间的数据不用传送，而是直接访问内存，加快了程序的效率。

（2）缺点：共享内存没有提供同步机制，这使得我们在使用共享内存进行进程之间的通信时，往往需要借助其他手段来保证进程之间的同步工作。

--------------------- 本文来自 YPT_victory 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/ypt523/article/details/79958188?utm_source=copy