【Linux】进程间通信(万字详解) —— 下篇

柔光的暖阳◎ 2024-04-20 06:40 92阅读 0赞

> **?Linux：**
> 
> --------------------
> 
>  *  **博客主页：**[一起去看日落吗][Link 1]
>  *  **分享博主的在Linux中学习到的知识和遇到的问题**
>  *  **`博主的能力有限，出现错误希望大家不吝赐教`**
>  *  **分享给大家一句我很喜欢的话：** 看似不起波澜的日复一日，一定会在某一天让你看见坚持的意义，祝我们都能在鸡零狗碎里找到闪闪的快乐???。
> 
> --------------------
> 
> ![在这里插入图片描述][0c3f31bc6bb5460689d5e339f5299830.jpeg_pic_center]

? ? ? ?

--------------------

#### 目录 ####

*  ?1. system V进程间通信
 *   *  ?1.1 system V共享内存
     *   *  ?1.1.1 共享内存的基本原理
         *  ?1.1.2 共享内存的数据结构
         *  ?1.1.3 共享内存的建立与释放
         *  ?1.1.4 共享内存的创建
         *  ?1.1.5 共享内存的释放
         *  ?1.1.6 共享内存的关联
         *  ?1.1.6 共享内存的去关联
         *  ?1.1.7 用共享内存实现serve&client通信
         *  ?1.1.8 共享内存与管道进行对比
     *  ?1.2 system V消息队列
     *   *  ?1.2.1 消息队列的基本原理
         *  ?1.2.2 消息队列的数据结构
         *  ?1.2.3 消息队列的创建
         *  ?1.2.4 消息队列的释放
         *  ?1.2.5 向消息队列发送数据
         *  ?1.2.6 从消息队列获取数据
     *  ?1.3 system V信号量
     *   *  ?1.3.1 信号量相关概念
         *  ?1.3.2 信号量数据结构
         *  ?1.3.3 信号量相关函数
         *  ?1.3.4 进程互斥

## ?1. system V进程间通信 ##

管道通信本质是基于文件的，也就是说操作系统并没有为此做过多的设计工作，而system V IPC是操作系统特地设计的一种通信方式。但是不管怎么样，它们的本质都是一样的，都是在想尽办法让不同的进程看到同一份由操作系统提供的资源。

system V IPC提供的通信方式有以下三种：

*  system V共享内存
 *  system V消息队列
 *  system V信号量

其中，system V共享内存和system V消息队列是以传送数据为目的的，而system V信号量是为了保证进程间的同步与互斥而设计的，虽然system V信号量和通信好像没有直接关系，但属于通信范畴。

system V共享内存和system V消息队列就类似于手机，用于沟通信息；system V信号量就类似于下棋比赛时用的棋钟，用于保证两个棋手之间的同步与互斥。

--------------------

### ?1.1 system V共享内存 ###

#### ?1.1.1 共享内存的基本原理 ####

共享内存让不同进程看到同一份资源的方式就是，在物理内存当中申请一块内存空间，然后将这块内存空间分别与各个进程各自的页表之间建立映射，再在虚拟地址空间当中开辟空间并将虚拟地址填充到各自页表的对应位置，使得虚拟地址和物理地址之间建立起对应关系，至此这些进程便看到了同一份物理内存，**这块物理内存就叫做共享内存。**

![在这里插入图片描述][1cab2ed709db4fc7a8f2f8458021628e.png]

**注意：**

这里所说的开辟物理空间、建立映射等操作都是调用系统接口完成的，也就是说这些动作都由操作系统来完成。

--------------------

#### ?1.1.2 共享内存的数据结构 ####

在系统当中可能会有大量的进程在进行通信，因此系统当中就可能存在大量的共享内存，那么操作系统必然要对其进行管理，所以共享内存除了在内存当中真正开辟空间之外，系统一定还要为共享内存维护相关的内核数据结构。

struct shmid_ds {
        
    	struct ipc_perm     shm_perm;   /* operation perms */
    	int         shm_segsz;  /* size of segment (bytes) */
    	__kernel_time_t     shm_atime;  /* last attach time */
    	__kernel_time_t     shm_dtime;  /* last detach time */
    	__kernel_time_t     shm_ctime;  /* last change time */
    	__kernel_ipc_pid_t  shm_cpid;   /* pid of creator */
    	__kernel_ipc_pid_t  shm_lpid;   /* pid of last operator */
    	unsigned short      shm_nattch; /* no. of current attaches */
    	unsigned short      shm_unused; /* compatibility */
    	void            *shm_unused2;   /* ditto - used by DIPC */
    	void            *shm_unused3;   /* unused */
    };

当我们申请了一块共享内存后，为了让要实现通信的进程能够看到同一个共享内存，因此每一个共享内存被申请时都有一个key值，这个key值用于标识系统中共享内存的唯一性。

每个共享内存的key值存储在shm\_perm这个结构体变量当中，其中ipc\_perm结构体的定义如下：

struct ipc_perm{
        
    	__kernel_key_t  key;
    	__kernel_uid_t  uid;
    	__kernel_gid_t  gid;
    	__kernel_uid_t  cuid;
    	__kernel_gid_t  cgid;
    	__kernel_mode_t mode;
    	unsigned short  seq;
    };

--------------------

#### ?1.1.3 共享内存的建立与释放 ####

共享内存的建立大致包括以下两个过程：

*  在物理内存当中申请共享内存空间。
 *  将申请到的共享内存挂接到地址空间，即建立映射关系。

共享内存的释放大致包括以下两个过程：

*  将共享内存与地址空间去关联，即取消映射关系。
 *  释放共享内存空间，即将物理内存归还给系统。

--------------------

#### ?1.1.4 共享内存的创建 ####

**1. 创建共享内存我们需要用shmget函数**

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

shmget函数的参数说明：

*  第一个参数key，表示待创建共享内存在系统当中的唯一标识。
 *  第二个参数size，表示待创建共享内存的大小。
 *  第三个参数shmflg，表示创建共享内存的方式。

shmget函数的返回值说明：

*  shmget调用成功，返回一个有效的共享内存标识符（用户层标识符）。
 *  shmget调用失败，返回-1。

**注意**： 我们把具有标定某种资源能力的东西叫做句柄，而这里shmget函数的返回值实际上就是共享内存的句柄，这个句柄可以在用户层标识共享内存，当共享内存被创建后，我们在后续使用共享内存的相关接口时，都是需要通过这个句柄对指定共享内存进行各种操作。

**2. 传入shmget函数的第一个参数key，需要我们使用ftok函数进行获取**

key_t ftok(const char *pathname, int proj_id);

ftok函数的作用就是，将一个已存在的路径名pathname和一个整数标识符proj\_id转换成一个key值，称为IPC键值，在使用shmget函数获取共享内存时，这个key值会被填充进维护共享内存的数据结构当中。需要注意的是，pathname所指定的文件必须存在且可存取。

**注意：**

使用ftok函数生成key值可能会产生冲突，此时可以对传入ftok函数的参数进行修改。  
需要进行通信的各个进程，在使用ftok函数获取key值时，都需要采用同样的路径名和和整数标识符，**进而生成同一种key值，然后才能找到同一个共享资源。**

**3. 传入shmget函数的第三个参数shmflg，常用的组合方式有以下两种：**

<table> 
 <thead> 
  <tr> 
   <th>组合方式</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>IPC_CREAT</td> 
   <td>如果内核中不存在键值与key相等的共享内存，则新建一个共享内存并返回该共享内存的句柄；如果存在这样的共享内存，则直接返回该共享内存的句柄</td> 
  </tr> 
  <tr> 
   <td>IPC_CREAT ｜IPC_EXCL</td> 
   <td>如果内核中不存在键值与key相等的共享内存，则新建一个共享内存并返回该共享内存的句柄；如果存在这样的共享内存，则出错返回</td> 
  </tr> 
 </tbody> 
</table>

我们就可以使用ftok和shmget函数创建一块共享内存了，创建后我们可以将共享内存的key值和句柄进行打印，以便观察

![在这里插入图片描述][3d3510c1dee14b43850f52fa3a5e7f4e.png]

我们可以使用ipcs命令查看有关进程间通信设施的信息。

![在这里插入图片描述][8eb956dbf350418aab3e2903a840fa8b.png]

单独使用ipcs命令时，会默认列出消息队列、共享内存以及信号量相关的信息，若只想查看它们之间某一个的相关信息，可以选择携带以下选项：

*  \-q：列出消息队列相关信息。
 *  \-m：列出共享内存相关信息。
 *  \-s：列出信号量相关信息。

根据ipcs命令的查看结果和我们的输出结果可以确认，共享内存已经创建成功了

**ipcs命令输出的每列信息**

<table> 
 <thead> 
  <tr> 
   <th>标题</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>key</td> 
   <td>系统区别各个共享内存的唯一标识</td> 
  </tr> 
  <tr> 
   <td>shmid</td> 
   <td>共享内存的用户层id（句柄）</td> 
  </tr> 
  <tr> 
   <td>owner</td> 
   <td>共享内存的拥有者</td> 
  </tr> 
  <tr> 
   <td>perms</td> 
   <td>共享内存的权限</td> 
  </tr> 
  <tr> 
   <td>bytes</td> 
   <td>共享内存的大小</td> 
  </tr> 
  <tr> 
   <td>nattch</td> 
   <td>关联共享内存的进程数</td> 
  </tr> 
  <tr> 
   <td>status</td> 
   <td>共享内存的状态</td> 
  </tr> 
 </tbody> 
</table>

**注意： key是在内核层面上保证共享内存唯一性的方式，而shmid是在用户层面上保证共享内存的唯一性**

--------------------

#### ?1.1.5 共享内存的释放 ####

通过上面创建共享内存的实验可以发现，**当我们的进程运行完毕后，申请的共享内存依旧存在，并没有被操作系统释放。实际上，管道是生命周期是随进程的，而共享内存的生命周期是随内核的**，也就是说进程虽然已经退出，但是曾经创建的共享内存不会随着进程的退出而释放。

这说明，**如果进程不主动删除创建的共享内存，那么共享内存就会一直存在，直到关机重启**（system V IPC都是如此），同时也说明了IPC资源是由内核提供并维护的。

**此时我们若是要将创建的共享内存释放，有两个方法，一就是使用命令释放共享内存，二就是在进程通信完毕后调用释放共享内存的函数进行释放。**

**1. 使用命令释放共享内存资源**

我们可以使用ipcrm -m shmid命令释放指定id的共享内存资源。

![在这里插入图片描述][1151122741ea4627aebf3fcd35be96ec.png]

**2. 使用程序释放共享内存资源**

控制共享内存我们需要用shmctl函数

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

shmctl函数的参数说明：

*  第一个参数shmid，表示所控制共享内存的用户级标识符。
 *  第二个参数cmd，表示具体的控制动作。
 *  第三个参数buf，用于获取或设置所控制共享内存的数据结构。

shmctl函数的返回值说明：

*  shmctl调用成功，返回0。
 *  shmctl调用失败，返回-1

**作为shmctl函数的第二个参数传入的常用的选项有以下三个：**

<table> 
 <thead> 
  <tr> 
   <th>选项</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>IPC_STAT</td> 
   <td>获取共享内存的当前关联值，此时参数buf作为输出型参数</td> 
  </tr> 
  <tr> 
   <td>IPC_SET</td> 
   <td>在进程有足够权限的前提下，将共享内存的当前关联值设置为buf所指的数据结构中的值</td> 
  </tr> 
  <tr> 
   <td>IPC_RMID</td> 
   <td>删除共享内存段</td> 
  </tr> 
 </tbody> 
</table>

共享内存被创建，两秒后程序自动移除共享内存，再过两秒程序就会自动退出。

#include <stdio.h>
    #include <sys/types.h> 
    #include <sys/ipc.h> 
    #include <sys/shm.h> 
    #include <unistd.h>
    		
    #define PATHNAME "/home/lighthouse/practice/lesson/lesson12/server.cc" //路径名
    
    #define PROJ_ID 0x6666 //整数标识符
    #define SIZE 4096 //共享内存的大小
    
    int main()
    {
        
    	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
    	if (key < 0){
        
    		perror("ftok");
    		return 1;
    	}
    	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL); //创建新的共享内存
    	if (shm < 0){
        
    		perror("shmget");
    		return 2;
    	}
    	printf("key: %x\n", key); //打印key值
    	printf("shm: %d\n", shm); //打印句柄
    
       sleep(20);
    	shmctl(shm, IPC_RMID, NULL); //释放共享内存
    	sleep(20);
    
    	return 0;
    }

> while :; do ipcs -m;echo “\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#”;sleep 1;done

通过监控脚本可以确定共享内存确实创建并且成功释放了。  
![在这里插入图片描述][35c744ecc3454c8081d811552ca6b0ff.png]

--------------------

#### ?1.1.6 共享内存的关联 ####

将共享内存连接到进程地址空间我们需要用shmat函数

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

shmat函数的参数说明：

*  第一个参数shmid，表示待关联共享内存的用户级标识符。
 *  第二个参数shmaddr，指定共享内存映射到进程地址空间的某一地址，通常设置为NULL，表示让内核自己决定一个合适的地址位置。
 *  第三个参数shmflg，表示关联共享内存时设置的某些属性。

shmat函数的返回值说明：

*  shmat调用成功，返回共享内存映射到进程地址空间中的起始地址。
 *  shmat调用失败，返回(void\*)-1。

shmat函数的第三个参数传入的常用的选项有以下三个：

<table> 
 <thead> 
  <tr> 
   <th>选项</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SHM_RDONLY</td> 
   <td>关联共享内存后只进行读取操作</td> 
  </tr> 
  <tr> 
   <td>SHM_RND</td> 
   <td>若shmaddr不为NULL，则关联地址自动向下调整为SHMLBA的整数倍。公式：shmaddr-(shmaddr%SHMLBA)</td> 
  </tr> 
  <tr> 
   <td>0</td> 
   <td>默认为读写权限</td> 
  </tr> 
 </tbody> 
</table>

我们可以尝试使用shmat函数对共享内存进行关联。

#include <stdio.h>
    #include <sys/types.h> 
    #include <sys/ipc.h> 
    #include <sys/shm.h> 
    #include <unistd.h>
    		
    #define PATHNAME "/home/lighthouse/practice/lesson/lesson12/server.cc" //路径名
    
    #define PROJ_ID 0x6666 //整数标识符
    #define SIZE 4096 //共享内存的大小
    
    int main()
    {
        
    	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
    	if (key < 0){
        
    		perror("ftok");
    		return 1;
    	}
    	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL); //创建新的共享内存
    	if (shm < 0){
        
    		perror("shmget");
    		return 2;
    	}
    	printf("key: %x\n", key); //打印key值
    	printf("shm: %d\n", shm); //打印句柄
    
    	printf("attach begin!\n");
    	sleep(2);
    	char* mem = (char*)shmat(shm, NULL, 0); //关联共享内存
    	if (mem == (void*)-1){
        
    		perror("shmat");
    		return 1;
    	}
    	printf("attach end!\n");
    	sleep(2);
    	
    	shmctl(shm, IPC_RMID, NULL); //释放共享内存
    	return 0;
        
    }

代码运行后发现关联失败，主要原因是我们使用shmget函数创建共享内存时，并没有对创建的共享内存设置权限，**所以创建出来的共享内存的默认权限为0，即什么权限都没有，因此server进程没有权限关联该共享内存**。

![在这里插入图片描述][5d997693bdd4444a83f064ee26795577.png]  
我们应该在使用shmget函数创建共享内存时，在其第三个参数处设置共享内存创建后的权限，权限的设置规则与设置文件权限的规则相同。

int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL | 0666); //创建权限为0666的共享内存

此时再运行程序，即可发现关联该共享内存的进程数由0变成了1，而共享内存的权限显示也不再是0，而是我们设置的666权限。

![在这里插入图片描述][a5a05dac50204bf6af407981a660aff5.png]

--------------------

#### ?1.1.6 共享内存的去关联 ####

取消共享内存与进程地址空间之间的关联我们需要用shmdt函数

int shmdt(const void *shmaddr);

shmdt函数的参数说明：

*  待去关联共享内存的起始地址，即调用shmat函数时得到的起始地址。

shmdt函数的返回值说明：

*  shmdt调用成功，返回0。
 *  shmdt调用失败，返回-1。

现在我们就能够取消共享内存与进程之间的关联了

#include <stdio.h>
    #include <sys/types.h> 
    #include <sys/ipc.h> 
    #include <sys/shm.h> 
    #include <unistd.h>
    		
    #define PATHNAME "/home/lighthouse/practice/lesson/lesson12/server.cc" //路径名
    
    #define PROJ_ID 0x6666 //整数标识符
    #define SIZE 4096 //共享内存的大小
    
    int main()
    {
        
    	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
    	if (key < 0){
        
    		perror("ftok");
    		return 1;
    	}
    	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL | 0666); //创建新的共享内存
    	if (shm < 0){
        
    		perror("shmget");
    		return 2;
    	}
    	printf("key: %x\n", key); //打印key值
    	printf("shm: %d\n", shm); //打印句柄
    
    	printf("attach begin!\n");
    	sleep(2);
    	char* mem = (char*)shmat(shm, NULL, 0); //关联共享内存
    	if (mem == (void*)-1){
        
    		perror("shmat");
    		return 1;
    	}
    	printf("attach end!\n");
    	sleep(2);
    	
    	printf("detach begin!\n");
    	sleep(2);
    	shmdt(mem); //共享内存去关联
    	printf("detach end!\n");
    	sleep(2);
    
    	shmctl(shm, IPC_RMID, NULL); //释放共享内存
    	return 0;
    }

运行程序，通过监控即可发现该共享内存的关联数由1变为0的过程，即取消了共享内存与该进程之间的关联。

![在这里插入图片描述][01e49c8b98cd46a994a80ffd79a207dc.png]  
**注意： 将共享内存段与当前进程脱离不等于删除共享内存，只是取消了当前进程与该共享内存之间的联系。**

--------------------

#### ?1.1.7 用共享内存实现serve&client通信 ####

在知道了共享内存的创建、关联、去关联以及释放后，现在可以尝试让两个进程通过共享内存进行通信了。在让两个进程进行通信之前，我们可以先测试一下这两个进程能否成功挂接到同一个共享内存上。

服务端负责创建共享内存，创建好后将共享内存和服务端进行关联，之后进入死循环，便于观察服务端是否挂接成功。

//server.cc
    #include "comm.hpp"
    
    int main()
    {
        
    	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
    	if (key < 0){
        
    		perror("ftok");
    		return 1;
    	}
    
    	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL | 0666); //创建新的共享内存
    	if (shm < 0){
        
    		perror("shmget");
    		return 2;
    	}
    	
    	printf("key: %x\n", key); //打印key值
    	printf("shm: %d\n", shm); //打印共享内存用户层id
    
    	char* mem = shmat(shm, NULL, 0); //关联共享内存
    
    	while (1){
        
    		//不进行操作
    	}
    
    	shmdt(mem); //共享内存去关联
    
    	shmctl(shm, IPC_RMID, NULL); //释放共享内存
    	return 0;
    }

客户端只需要直接和服务端创建的共享内存进行关联即可，之后也进入死循环，便于观察客户端是否挂接成功。

//client.cc
    #include "comm.hpp"
    
    int main()
    {
        
    	key_t key = ftok(PATHNAME, PROJ_ID); //获取与server进程相同的key值
    	if (key < 0){
        
    		perror("ftok");
    		return 1;
    	}
    	int shm = shmget(key, SIZE, IPC_CREAT); //获取server进程创建的共享内存的用户层id
    	if (shm < 0){
        
    		perror("shmget");
    		return 2;
    	}
    
    	printf("key: %x\n", key); //打印key值
    	printf("shm: %d\n", shm); //打印共享内存用户层id
    
    	char* mem = shmat(shm, NULL, 0); //关联共享内存
    
    	int i = 0;
    	while (1){
        
    		//不进行操作
    	}
    
    	shmdt(mem); //共享内存去关联
    	return 0;
    }

为了让服务端和客户端在使用ftok函数获取key值时，能够得到同一种key值，那么服务端和客户端传入ftok函数的路径名和和整数标识符必须相同，这样才能生成同一种key值，进而找到同一个共享资源进行挂接。这里我们可以将这些需要共用的信息放入一个头文件当中，服务端和客户端共用这个头文件即可。

//comm.hpp
    #include <iostream>
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <unistd.h>
    
    #define PATHNAME "/home/lighthouse/practice/lesson/lesson12/server.cc" //路径名
    
    #define PROJ_ID 0x6666 //整数标识符
    #define SIZE 4096 //共享内存的大小

先后运行服务端和客户端后，通过监控脚本可以看到服务端和客户端所关联的是同一个共享内存，共享内存关联的进程数也是2，表示服务端和客户端挂接共享内存成功。

![在这里插入图片描述][bc04942690a8400e95081f5128aa8d7f.png]  
此时我们就可以让服务端和客户端进行通信了，这里以简单的发送字符串为例。

客户端不断向共享内存写入数据：

//客户端不断向共享内存写入数据
    int i = 0;
    while (1){
        
    	mem[i] = 'A' + i;
    	i++;
    	mem[i] = '\0';
    	sleep(1);
    }

服务端不断读取共享内存当中的数据并输出：

//服务端不断读取共享内存当中的数据并输出
    while (1){
        
    	printf("client# %s\n", mem);
    	sleep(1);
    }

此时先运行服务端创建共享内存，当我们运行客户端时服务端就开始不断输出数据，说明服务端和客户端是能够正常通信的。

![在这里插入图片描述][9e4c1a9ddf5b49b4aee5471228b63d57.png]

--------------------

#### ?1.1.8 共享内存与管道进行对比 ####

当共享内存创建好后就不再需要调用系统接口进行通信了，而管道创建好后仍需要read、write等系统接口进行通信。实际上，共享内存是所有进程间通信方式中最快的一种通信方式。

我们先来看看管道通信：

![在这里插入图片描述][9952aef1ad6d4d289da8e6b53ccf9383.png]

将一个文件从一个进程传输到另一个进程需要进行四次拷贝操作：

1.  服务端将信息从输入文件复制到服务端的临时缓冲区中。
2.  将服务端临时缓冲区的信息复制到管道中。
3.  客户端将信息从管道复制到客户端的缓冲区中。
4.  将客户端临时缓冲区的信息复制到输出文件中。

我们再来看看共享内存通信：

![在这里插入图片描述][9dff6f9fc9484995a1ed600edcb3074b.png]

从这张图可以看出，使用共享内存进行通信，将一个文件从一个进程传输到另一个进程只需要进行两次拷贝操作：

1.  从输入文件到共享内存。
2.  从共享内存到输出文件。

所以共享内存是所有进程间通信方式中最快的一种通信方式，因为该通信方式需要进行的拷贝次数最少。

**但是共享内存也是有缺点的，我们知道管道是自带同步与互斥机制的，但是共享内存并没有提供任何的保护机制，包括同步与互斥。**

--------------------

### ?1.2 system V消息队列 ###

#### ?1.2.1 消息队列的基本原理 ####

消息队列实际上就是在系统当中创建了一个队列，队列当中的每个成员都是一个数据块，这些数据块都由类型和信息两部分构成，两个互相通信的进程通过某种方式看到同一个消息队列，这两个进程向对方发数据时，都在消息队列的队尾添加数据块，这两个进程获取数据块时，都在消息队列的队头取数据块。

![在这里插入图片描述][6df09a8f29764ca3b7f3da50f092441e.png]  
**其中消息队列当中的某一个数据块是由谁发送给谁的，取决于数据块的类型。**

*  消息队列提供了一个从一个进程向另一个进程发送数据块的方法。
 *  每个数据块都被认为是有一个类型的，接收者进程接收的数据块可以有不同的类型值。
 *  和共享内存一样，消息队列的资源也必须自行删除，否则不会自动清除，因为system V IPC资源的生命周期是随内核的。

--------------------

#### ?1.2.2 消息队列的数据结构 ####

系统当中也可能会存在大量的消息队列，系统一定也要为消息队列维护相关的内核数据结构。

struct msqid_ds {
        
    	struct ipc_perm msg_perm;
    	struct msg *msg_first;      /* first message on queue,unused  */
    	struct msg *msg_last;       /* last message in queue,unused */
    	__kernel_time_t msg_stime;  /* last msgsnd time */
    	__kernel_time_t msg_rtime;  /* last msgrcv time */
    	__kernel_time_t msg_ctime;  /* last change time */
    	unsigned long  msg_lcbytes; /* Reuse junk fields for 32 bit */
    	unsigned long  msg_lqbytes; /* ditto */
    	unsigned short msg_cbytes;  /* current number of bytes on queue */
    	unsigned short msg_qnum;    /* number of messages in queue */
    	unsigned short msg_qbytes;  /* max number of bytes on queue */
    	__kernel_ipc_pid_t msg_lspid;   /* pid of last msgsnd */
    	__kernel_ipc_pid_t msg_lrpid;   /* last receive pid */
    };

可以看到消息队列数据结构的第一个成员是msg\_perm，它和shm\_perm是同一个类型的结构体变量，ipc\_perm结构体的定义如下：

--------------------

#### ?1.2.3 消息队列的创建 ####

创建消息队列我们需要用msgget函数

int msgget(key_t key, int msgflg);

*  创建消息队列也需要使用ftok函数生成一个key值，这个key值作为msgget函数的第一个参数。
 *  msgget函数的第二个参数，与创建共享内存时使用的shmget函数的第三个参数相同。
 *  消息队列创建成功时，msgget函数返回的一个有效的消息队列标识符（用户层标识符）。

--------------------

#### ?1.2.4 消息队列的释放 ####

释放消息队列我们需要用msgctl函数

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

*  msgctl函数的参数与释放共享内存时使用的shmctl函数的三个参数相同，只不过msgctl函数的第三个参数传入的是消息队列的相关数据结构。

--------------------

#### ?1.2.5 向消息队列发送数据 ####

向消息队列发送数据我们需要用msgsnd函数

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

msgsnd函数的参数说明：

*  第一个参数msqid，表示消息队列的用户级标识符。
 *  第二个参数msgp，表示待发送的数据块。
 *  第三个参数msgsz，表示所发送数据块的大小
 *  第四个参数msgflg，表示发送数据块的方式，一般默认为0即可。

msgsnd函数的返回值说明：

*  msgsnd调用成功，返回0。
 *  msgsnd调用失败，返回-1。

其中msgsnd函数的第二个参数必须为以下结构：

struct msgbuf{
        
    	long mtype;       /* message type, must be > 0 */
    	char mtext[1];    /* message data */
    };

**注意： 该结构当中的第二个成员mtext即为待发送的信息，当我们定义该结构时，mtext的大小可以自己指定。**

--------------------

#### ?1.2.6 从消息队列获取数据 ####

从消息队列获取数据我们需要用msgrcv函数

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msgrcv函数的参数说明：

*  第一个参数msqid，表示消息队列的用户级标识符。
 *  第二个参数msgp，表示获取到的数据块，是一个输出型参数。
 *  第三个参数msgsz，表示要获取数据块的大小
 *  第四个参数msgtyp，表示要接收数据块的类型。

msgrcv函数的返回值说明：

*  msgsnd调用成功，返回实际获取到mtext数组中的字节数。
 *  msgsnd调用失败，返回-1。

--------------------

### ?1.3 system V信号量 ###

#### ?1.3.1 信号量相关概念 ####

*  由于进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系叫做进程互斥。
 *  系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源。
 *  在进程中涉及到临界资源的程序段叫临界区。
 *  IPC资源必须删除，否则不会自动删除，因为system V IPC的生命周期随内核。

--------------------

#### ?1.3.2 信号量数据结构 ####

在系统当中也为信号量维护了相关的内核数据结构

struct semid_ds {
        
    	struct ipc_perm sem_perm;       /* permissions .. see ipc.h */
    	__kernel_time_t sem_otime;      /* last semop time */
    	__kernel_time_t sem_ctime;      /* last change time */
    	struct sem  *sem_base;      /* ptr to first semaphore in array */
    	struct sem_queue *sem_pending;      /* pending operations to be processed */
    	struct sem_queue **sem_pending_last;    /* last pending operation */
    	struct sem_undo *undo;          /* undo requests on this array */
    	unsigned short  sem_nsems;      /* no. of semaphores in array */
    };

信号量数据结构的第一个成员也是ipc\_perm类型的结构体变量，ipc\_perm结构体的定义如下：

--------------------

#### ?1.3.3 信号量相关函数 ####

**1. 信号量集的创建**

创建信号量集我们需要用semget函数

int semget(key_t key, int nsems, int semflg);

*  创建信号量集也需要使用ftok函数生成一个key值，这个key值作为semget函数的第一个参数。
 *  semget函数的第二个参数nsems，表示创建信号量的个数。
 *  semget函数的第三个参数，与创建共享内存时使用的shmget函数的第三个参数相同。
 *  信号量集创建成功时，semget函数返回的一个有效的信号量集标识符（用户层标识符）。

**2. 信号量集的删除**

删除信号量集我们需要用semctl函数

int semctl(int semid, int semnum, int cmd, ...);

**3. 信号量集的操作**

对信号量集进行操作我们需要用semop函数

int semop(int semid, struct sembuf *sops, unsigned nsops);

--------------------

#### ?1.3.4 进程互斥 ####

进程间通信通过共享资源来实现，这虽然解决了通信的问题，但是也引入了新的问题，那就是通信进程间共用的临界资源，若是不对临界资源进行保护，就可能产生各个进程从临界资源获取的数据不一致等问题。

保护临界资源的本质是保护临界区，**我们把进程代码中访问临界资源的代码称之为临界区，信号量就是用来保护临界区的，信号量分为二元信号量和多元信号量。**

比如当前有一块大小为100字节的资源，我们若是一25字节为一份，那么该资源可以被分为4份，那么此时这块资源可以由4个信号量进行标识。

信号量本质是一个计数器，在二元信号量中，信号量的个数为1（相当于将临界资源看成一整块），二元信号量本质解决了临界资源的互斥问题

无论什么时候都只会有一个进程在对同一份共享内存进行访问操作，也就解决了临界资源的互斥问题。

--------------------

[Link 1]: https://blog.csdn.net/m0_60338933?type=blog
[0c3f31bc6bb5460689d5e339f5299830.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0dd2feed3c4644eebb40dd950dbfc6f9.jpeg
[1cab2ed709db4fc7a8f2f8458021628e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/05a6974c4c924990aa19be18aa60c5f3.png
[3d3510c1dee14b43850f52fa3a5e7f4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0e159ac3663244f2bb6937f35e42aeaa.png
[8eb956dbf350418aab3e2903a840fa8b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b8333dee2e3a4234afd503fc06f52dc7.png
[1151122741ea4627aebf3fcd35be96ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/938fa0843a31457ebbfdcaaa6aef61db.png
[35c744ecc3454c8081d811552ca6b0ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/289223d02c524f11b4b5c34fd20ec021.png
[5d997693bdd4444a83f064ee26795577.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/61b96e58692a4b7dacd85c8e91ed36b7.png
[a5a05dac50204bf6af407981a660aff5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/82c53b63f2b24586b7edbb1bc93b3c7b.png
[01e49c8b98cd46a994a80ffd79a207dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e496f7bb8c5d4356abfd13b57bad6d51.png
[bc04942690a8400e95081f5128aa8d7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/aab23cd886f84696979f925682914e0b.png
[9e4c1a9ddf5b49b4aee5471228b63d57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/af4bd4679c5c4b4fbe308572cdccce5c.png
[9952aef1ad6d4d289da8e6b53ccf9383.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/88c5797250a9446a926568076721f733.png
[9dff6f9fc9484995a1ed600edcb3074b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e8c9b9095ed9469b85b587d8d7af9a03.png
[6df09a8f29764ca3b7f3da50f092441e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b95970241c704fe198c2cf8776915fa3.png