Linux 进程间通讯（IPC）详解

进程间通讯（IPC）深入解析

一、进程间通讯概述

在操纵系统里，差别进程间常常必要进行数据交换、同步协调等操纵，进程间通讯（Inter - Process Communication，IPC）机制应运而生。在Linux系统中，常见的IPC机制有管道、信号量、共享内存、消息队列和套接字。这些机制各自具备独特的特性，适用于差别的应用场景，并且在各类系统和应用步伐开发中得到广泛应用，也是技能口试中的重点考查内容。
思考题目1：为什么必要进程间通讯？

在多进程的环境下，各个进程通常是独立运行的，但有些环境下，它们必要协同工作。比如，一个进程负责收集用户输入，另一个进程负责对这些输入进行处理，这就必要两个进程之间进行数据传递。别的，当多个进程必要访问同一资源时，为了制止辩论，就必要通过进程间通讯来进行同步和协调。
思考题目2：差别的IPC机制适用于哪些场景？

差别的IPC机制有差别的特点和适用场景。比方，管道适合简单的父子进程间的数据传递；信号量紧张用于进程间的同步和互斥；共享内存适合大量数据的快速传输；消息队列适用于必要按消息类型分类处理数据的场景；套接字则常用于网络环境下的进程间通讯。
二、管道

2.1 管道分类

管道分为有名（定名）管道和无名管道。
有名管道

有名管道也叫定名管道，它以文件的形式存在于文件系统中，差别进程可以通过这个文件进行通讯，即便这些进程没有亲缘关系。

1. mkfifo fifo
2.                 # 创建一个叫做fifo的管道

复制代码

创建完成后，利用ls -l命令检察文件类型，会看到文件类型为p，这代表该文件是一个管道文件。
无名管道

无名管道是通过系统调用pipe创建的，它没有对应的文件系统实体，只能用于具有亲缘关系的进程（如父子进程）之间的通讯。
2.2 管道的特点和阻塞举动

数据存储

管道大小在文件系统层面显示为零，但数据实际上是存储在内存中的。管道本质上是内核中的一块缓冲区，用于临时存储要传输的数据。
打开条件

读打开和写打开的进程必须同时打开管道。若只有读进程打开管道，读操纵会阻塞，直到有写进程打开并写入数据；若只有写进程打开管道，写操纵也会阻塞，直到有读进程打开管道读取数据。
读阻塞

读打开的进程在管道没有数据时会阻塞，直到有数据被写入管道。当所有写端关闭且管道中的数据都被读完后，读操纵会返回0，表示已到达文件末端。
写关闭处理

写打开的进程关闭管道时，读打开的进程会返回零。此时读进程知道写进程已经停止写入数据，可以竣事读取操纵。
2.3 怎样利用管道在两个进程之间传递数据？

第一步，创建一个管道文件

利用mkfifo命令创建一个定名管道文件，比方：

1. mkfifo fifo

复制代码

第二步，创建两个进程，a.c和b.c

1. //a.c用来往管道里面写数据：
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <fcntl.h>
8. int main()
9. {
10.     int fd = open("./fifo", O_WRONLY);
11.     if (fd == -1)
12.     {
13.         perror("open");
14.         exit(1);
15.     }
16.     printf("fd=%d\n", fd);
17.     while (1)
18.     {
19.         printf("input:\n");
20.         char buff[128] = {0};
21.         fgets(buff, 128, stdin);
22.         if (strncmp(buff, "end", 3) == 0)
23.         {
24.             break;
25.         }
26.         write(fd, buff, strlen(buff));
27.     }
28.     close(fd);
29.     exit(0);
30. }

复制代码

1. //b.c用来在管道里面收数据：
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <fcntl.h>
8. int main()
9. {
10.     int fd = open("./fifo", O_RDONLY);
11.     if (fd == -1)
12.     {
13.         perror("open");
14.         exit(1);
15.     }
16.     printf("fd=%d\n", fd);
17.     while (1)
18.     {
19.         char buff[128] = {0};
20.         int n = read(fd, buff, 127);
21.         if (n == 0)
22.         {
23.             break;
24.         }
25.         printf("buff = %s\n", buff);
26.     }
27.     close(fd);
28.     exit(0);
29. }

复制代码

第三步，同时打开两个文件，进行通讯

当利用管道进行数据传输时，必须有两个进程同时打开这个管道文件，一个负责读，一个负责写，否则不能正常打开。在打开文件后，当写进程没有进行写操纵前，读进程将会阻塞。
管道的特点是读打开和写打开的进程可以循环读写数据。当管道文件被关闭后，读操纵返回值为0，可以作为读进程竣事的条件。
2.4 无名管道

无名管道通过pipe来创建。其实现原理是必要提供一个整型数组，数组的两个元素分别作为读端和写端的文件形貌符。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <unistd.h>
6. int main()
7. {
8.     int fd[2];
9.     if (pipe(fd) == -1)
10.     {
11.         perror("pipe");
12.         exit(1);
13.     }
14.     // 父进程写，子进程读
15.     pid_t pid = fork();
16.     if (pid == -1)
17.     {
18.         perror("fork");
19.         exit(1);
20.     }
21.     if (pid == 0)
22.     {
23.         close(fd[1]);
24.         while (1)
25.         {
26.             char buff[128] = {0};
27.             if (read(fd[0], buff, 127) == 0)
28.             {
29.                 break;
30.             }
31.             printf("child read:%s\n", buff);
32.         }
33.         close(fd[0]);
34.     }
35.     else
36.     {
37.         close(fd[0]);
38.         while (1)
39.         {
40.             printf("input:\n");
41.             char buff[128] = {0};
42.             fgets(buff, 128, stdin);
43.             if (strncmp(buff, "end", 3) == 0)
44.             {
45.                 break;
46.             }
47.             write(fd[1], buff, strlen(buff));
48.         }
49.         close(fd[1]);
50.     }
51.     exit(0);
52. }

复制代码

2.5 有名管道和无名管道的区别

• 通讯范围：无名管道只能在父子进程之间通讯，而有名管道可以在任意两个进程之间通讯。
  
• 存在形式：无名管道没有对应的文件系统实体，而有名管道以文件的形式存在于文件系统中。
  

2.6 管道的通讯方式

管道的通讯方式是半双工，即能发送和接收数据，但不能同时进行发送和接收操纵。
2.7 写入管道的数据位置

写入管道的数据存储在内存中。不利用文件进行数据传递是因为利用文件进行传递涉及到I/O操纵，效率较低，而管道直接在内存中操纵，数据传输速率更快。
2.8 管道的实现原理

假设管道有一个分配的内存空间，将其划分为一个字节一个字节的单位，有两个操纵这块空间的指针。用size来表示管道的总大小，设一个头指针和一个尾指针指向管道的起始位置。写入数据时，头指针往后移动，指向待写入的下一个位置；读数据时，读掉尾指针地点位置的数据，然后尾指针往后移动。只要尾指针赶上头指针，说明管道中的数据已读完。等到头指针指到内存最末端时，会循环到起始地址。管道的内存是有限的，在没读掉的位置不能写入数据，就像一个循环队列一样。
思考题目3：管道的缓冲区大小有限制吗？如果数据量凌驾缓冲区大小会怎样？

管道的缓冲区大小是有限制的，差别的系统大概有差别的默认值，通常为几KB到几十KB不等。当数据量凌驾缓冲区大小时，写操纵会阻塞，直到有充足的空间可以继承写入数据。这是为了防止数据溢出，保证数据的有序传输。
思考题目4：管道在多进程环境下大概会出现哪些题目？怎样解决？

在多进程环境下，管道大概会出现数据竞争、死锁等题目。比方，多个写进程同时向管道写入数据大概会导致数据混乱；如果读进程和写进程的操纵不协调，大概会出现死锁。解决这些题目可以利用同步机制，如信号量、互斥锁等，来协调进程对管道的访问。
2.9 写端关闭和读端关闭的处理

当写端关闭时，读端read()会返回0；当读关闭时，写端write()会异常停止（触发SIGPIPE信号）。
三、信号量

3.1 PV操纵

信号量通常是一个正数值，一般代表可用资源的数量。对信号量的操纵紧张有PV操纵。

• P操纵：获取资源，对信号量的值减一。如果减一后信号量的值小于0，进程会进入阻塞状态，等候其他进程释放资源。
  
• V操纵：释放资源，对信号量的值加一。如果加一后信号量的值小于等于0，说明有进程在等候该资源，会唤醒一个等候的进程。
  

3.2 相干概念

• 临界资源：一次仅允许一个进程利用的共享资源，如打印机、共享内存区域等。
  
• 临界区：访问临界资源的代码段。为了保证临界资源的准确利用，必要对临界区进行掩护，防止多个进程同时访问。
  

3.3 信号量的操纵步骤

• 创建 初始化：利用semget函数创建信号量集，并利用semctl函数进行初始化。
  
• P操纵，获取资源：利用semop函数执行P操纵，获取对临界资源的访问权限。
  
• V操纵，释放资源：利用semop函数执行V操纵，释放对临界资源的访问权限。PV操纵没有严格的先后顺序，要根据当时的利用需求来决定。
  
• 删除信号量：利用semctl函数删除信号量集。
  

3.4 信号量的操纵和接口

信号量的紧张操纵函数有semget（创建）、semctl（控制，初始化）和semop（PV操纵）。

1. //sem.h
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/sem.h>
8. union semun
9. {
10.     int val;   
11. };
13. void sem_init();
14. void sem_p();
15. void sem_v();
16. void sem_destroy();

复制代码

1. //sem.c
2. #include "sem.h"
3. static int semid = -1;
5. void sem_init()
6. {
7.     semid = semget((key_t)1234, 1, IPC_CREAT | IPC_EXCL | 0600);
8.     if (semid == -1)
9.     {
10.         semid = semget((key_t)1234, 1, IPC_CREAT | 0600);
11.         if (semid == -1)
12.         {
13.             perror("semget");
14.             return;
15.         }
16.     }
17.     else
18.     {
19.         union semun a;
20.         a.val = 1;
21.         if (semctl(semid, 0, SETVAL, a) == -1) // SETVAL表示初始化值
22.         {
23.             perror("semctl setval");
24.         }
25.     }
26. }
28. void sem_p()
29. {
30.     struct sembuf buf;
31.     buf.sem_num = 0; // 信号量的下标
32.     buf.sem_op = -1;
33.     buf.sem_flg = SEM_UNDO; // 这个标志位表示着当操作发生异常时由内核释放资源，避免资源一直占用
34.     if (semop(semid, &buf, 1) == -1)
35.     {
36.         perror("semop p");
37.     }
38. }
40. void sem_v()
41. {
42.     struct sembuf buf;
43.     buf.sem_num = 0;
44.     buf.sem_op = 1;
45.     buf.sem_flg = SEM_UNDO; // 这个标志位表示着当操作发生异常时由内核释放资源，避免资源一直占用
46.     if (semop(semid, &buf, 1) == -1)
47.     {
48.         perror("semop v");
49.     }
50. }
52. void sem_destroy()
53. {
54.     if (semctl(semid, 0, IPC_RMID) == -1) // IPC_RMID表示删除
55.     {
56.         perror("semctl destroy");
57.     }   
58. }

复制代码

3.5 创建两个进程利用信号量进行资源调用

1. //a.c
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include "sem.h"
8. int main()
9. {
10.     sem_init();
11.     for (int i = 0; i < 5; i++)
12.     {
13.         sem_p();
14.         printf("A");
15.         fflush(stdout);
16.         int n = rand() % 3;
17.         sleep(n);
19.         printf("A");
20.         fflush(stdout);
21.         n = rand() % 3;
22.         sleep(n);
23.         sem_v();
24.     }
25.     return 0;
26. }

复制代码

1. //b.c
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include "sem.h"
8. int main()
9. {
10.     sem_init();
11.     for (int i = 0; i < 5; i++)
12.     {
13.         sem_p();
14.         printf("B");
15.         fflush(stdout);
16.         int n = rand() % 3;
17.         sleep(n);
19.         printf("B");
20.         fflush(stdout);
21.         n = rand() % 3;
22.         sleep(n);
23.         sem_v();
24.     }
25.     sleep(10);
26.     sem_destroy();
27.     return 0;
28. }

复制代码

思考题目5：信号量的值可以为负数吗？负数代表什么寄义？

信号量的值可以为负数。当信号量的值为负数时，其绝对值表示正在等候该资源的进程数量。比方，信号量的值为 -2，表示有两个进程正在等候该资源的释放。
思考题目6：如果在利用信号量时忘记释放资源（即没有执行V操纵）会怎样？

如果忘记执行V操纵，信号量的值不会增加，其他等候该资源的进程将一直处于阻塞状态，无法获取资源，从而导致死锁或资源饥饿题目。因此，在利用信号量时，必须确保在适当的时间执行V操纵，释放资源。
四、共享内存

4.1 共享内存的原理和优势

共享内存是一种高效的进程间通讯方式，它允许差别进程直接访问同一块物理内存区域，制止了数据的多次拷贝，从而提高了数据传输的效率。

1. //a.c
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/shm.h>
8. int main()
9. {
10.     // 创建共享内存
11.     int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);
12.     if (shmid == -1)
13.     {
14.         perror("shmget");
15.         exit(1);
16.     }
17.     // 获取共享内存
18.     char* s = (char*)shmat(shmid, NULL, 0);
19.     if (s == (char*)-1)
20.     {
21.         perror("shmat");
22.         exit(1);
23.     }
24.     while (1)
25.     {
26.         char buff[128] = {0};
27.         fgets(buff, 128, stdin);
28.         strcpy(s, buff);
29.         if (strncmp(buff, "end", 3) == 0)
30.         {
31.             break;
32.         }
33.     }
34.     // 分离共享内存
35.     shmdt(s);
36.     exit(0);
37. }

复制代码

1. //b.c
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/shm.h>
8. int main()
9. {
10.     // 创建共享内存
11.     int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);
12.     if (shmid == -1)
13.     {
14.         perror("shmget");
15.         exit(1);
16.     }
17.     // 获取共享内存
18.     char* s = (char*)shmat(shmid, NULL, 0);
19.     if (s == (char*)-1)
20.     {
21.         perror("shmat");
22.         exit(1);
23.     }
24.     while (1)
25.     {
26.         if (strncmp(s, "end", 3) == 0)
27.         {
28.             break;
29.         }
30.         printf("s=%s", s);
31.         sleep(1);
32.     }
33.     // 分离共享内存
34.     shmdt(s);
35.     // 销毁共享内存
36.     shmctl(shmid, IPC_RMID, NULL);
37.     exit(0);
38. }

复制代码

4.2 存在题目及改进方案

上述代码存在题目：当没有输入值的时间，b.c会循环打印当时的共享内存中的值。改进方案是利用信号量，让两个步伐不能同时访问临界资源。
4.3 共享内存和信号量的利用

必要利用信号量的两个文件sem.c和sem.h，跟之前差别的是之前利用了一个信号量，这次必要利用两个。

1. //sem.h
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/sem.h>
8. union semun
9. {
10.     int val;   
11. };
13. void sem_init();
14. void sem_p(int index);
15. void sem_v(int index);
16. void sem_destroy();

复制代码

1. //sem.c
2. #include "sem.h"
3. static int semid = -1;
5. void sem_init()
6. {
7.     semid = semget((key_t)1234, 2, IPC_CREAT | IPC_EXCL | 0600);
8.     if (semid == -1)
9.     {
10.         semid = semget((key_t)1234, 2, IPC_CREAT | 0600);
11.         if (semid == -1)
12.         {
13.             perror("semget");
14.             return;
15.         }
16.     }
17.     else
18.     {
19.         union semun a;
20.         int arr[2] = {1, 0};
21.         for (int i = 0; i < 2; i++)
22.         {
23.             a.val = arr[i];
24.             if (semctl(semid, i, SETVAL, a) == -1) // SETVAL表示初始化值
25.             {
26.                 perror("semctl setval");
27.             }            
28.         }        
29.     }
30. }
32. void sem_p(int index)
33. {
34.     struct sembuf buf;
35.     buf.sem_num = index; // 信号量的下标
36.     buf.sem_op = -1;
37.     buf.sem_flg = SEM_UNDO; // 这个标志位表示着当操作发生异常时由内核释放资源，避免资源一直占用
38.     if (semop(semid, &buf, 1) == -1)
39.     {
40.         perror("semop p");
41.     }
42. }
44. void sem_v(int index)
45. {
46.     struct sembuf buf;
47.     buf.sem_num = index;
48.     buf.sem_op = 1;
49.     buf.sem_flg = SEM_UNDO; // 这个标志位表示着当操作发生异常时由内核释放资源，避免资源一直占用
50.     if (semop(semid, &buf, 1) == -1)
51.     {
52.         perror("semop v");
53.     }
54. }
56. void sem_destroy()
57. {
58.     if (semctl(semid, 0, IPC_RMID) == -1) // IPC_RMID表示删除
59.     {
60.         perror("semctl destroy");
61.     }   
62. }

复制代码

1. //a.c
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/shm.h>
7. #include "sem.h"
9. int main()
10. {
11.     // 创建共享内存
12.     int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);
13.     if (shmid == -1)
14.     {
15.         perror("shmget");
16.         exit(1);
17.     }
18.     // 映射共享内存
19.     char* s = (char*)shmat(shmid, NULL, 0);
20.     if (s == (char*)-1)
21.     {
22.         perror("shmat");
23.         exit(1);
24.     }
25.     sem_init();
26.     while (1)
27.     {
28.         printf("input:\n");
29.         char buff[128] = {0};
30.         fgets(buff, 128, stdin);
31.         sem_p(0); // s1,第一个信号量，初始值为1
32.         strcpy(s, buff);
33.         sem_v(1); // s2,第二个信号量，初始值为0
34.         if (strncmp(buff, "end", 3) == 0)
35.         {
36.             break;
37.         }
38.     }
39.     // 分离共享内存
40.     shmdt(s);
41.     exit(0);
42. }

复制代码

1. //b.c
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/shm.h>
7. #include "sem.h"
9. int main()
10. {
11.     // 创建共享内存
12.     int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);
13.     if (shmid == -1)
14.     {
15.         perror("shmget");
16.         exit(1);
17.     }
18.     // 获取共享内存
19.     char* s = (char*)shmat(shmid, NULL, 0);
20.     if (s == (char*)-1)
21.     {
22.         perror("shmat");
23.         exit(1);
24.     }
25.     sem_init();
26.     while (1)
27.     {
28.         sem_p(1);
29.         if (strncmp(s, "end", 3) == 0)
30.         {
31.             break;
32.         }
33.         printf("s=%s", s);
34.         sem_v(0);
35.     }
36.     sem_destroy();
37.     // 断开共享内存映射
38.     shmdt(s);
39.     // 销毁
40.     shmctl(shmid, IPC_RMID, NULL);
41.     exit(0);
42. }

复制代码

4.4 共享内存和管道的区别

共享内存对物理内存进行操纵，管道对内核缓冲区进行操纵，二者存在以下差别：
内存位置与管理方式

• 共享内存：共享内存是在物理内存中开发一块特定的区域，通过操纵系统的内存管理机制，将其映射到差别进程的虚拟地址空间中。这样，多个进程可以直接访问同一块物理内存，实现数据共享。操纵系统负责管理共享内存的分配与回收，进程通过系统调用如shmget、shmat等来请求和利用共享内存。比方，在多个进程必要频繁共享大量数据，如数据库系统中多个查询进程大概必要共享数据缓存时，就可以利用共享内存。
  
• 管道：管道的内核缓冲区是由操纵系统在内核空间中分配的一块内存区域，用于暂存管道两端进程间传输的数据。它的大小通常有一定限制，并且由操纵系统自动管理其数据的收支和空间利用。当进程向管道写入数据时，数据被复制到内核缓冲区；读进程从管道读取数据时，再从内核缓冲区复制到用户空间。比方，在ls | grep这样的命令组合中，ls命令的输出通过管道传输到grep命令，中心的数据就是暂存在管道的内核缓冲区中。
  

数据访问特性

• 共享内存：进程可以直接对共享内存进行读写操纵，就像访问自己的内存一样，速率非常快，因为不必要进行数据在用户空间和内核空间之间的复制。但是，由于多个进程可以同时访问共享内存，为了保证数据的同等性和完整性，必要利用同步机制，如信号量、互斥锁等，来协调进程对共享内存的访问。否则，大概会出现数据竞争等题目。
  
• 管道：管道的读写是有方向的，数据只能从写端流向读端。写进程将数据写入内核缓冲区，读进程从内核缓冲区读取数据。当管道满时，写进程会被阻塞，直到有数据被读走，腾出空间；当管道空时，读进程会被阻塞，直到有数据写入。这种机制保证了数据的有序传输，但也意味着数据的读写是顺序进行的，不能像共享内存那样随机访问。
  

数据可见性与持续性

• 共享内存：一旦数据被写入共享内存，只要其他进程有访问权限，就可以立刻看到更新后的数据，数据在共享内存中的存在是持续性的，直到被显式修改或删除。即使所有利用共享内存的进程都临时退出，共享内存中的数据仍旧存在于物理内存中，只要没有被操纵系统回收或其他进程修改，下次进程再访问时，数据依然保持原来的状态。
  
• 管道：管道中的数据具有临时性和一次性的特点。当数据被读进程从内核缓冲区读取后，数据就从管道中消失了，其他进程无法再次读取到雷同的数据。而且，当所有与管道相干的文件形貌符都被关闭后，管道所占用的内核缓冲区资源会被操纵系统自动释放，其中的数据也会被清除。
  

思考题目7：共享内存大概会带来哪些安全隐患？怎样防范？

共享内存大概带来的安全隐患包括数据泄露、数据被恶意篡改等。由于多个进程可以直接访问共享内存，若没有适当的权限控制和加密机制，敏感数据大概会被其他进程获取或修改。防范措施包括设置合理的访问权限，对共享内存中的数据进行加密处理，以及利用同步机制确保数据的同等性和完整性。
思考题目8：如果多个进程同时对共享内存进行写操纵会怎样？

如果多个进程同时对共享内存进行写操纵，会导致数据竞争题目，大概会使共享内存中的数据变得混乱，出现数据不同等的环境。为了制止这种环境，必要利用同步机制，如信号量、互斥锁等，来保证同一时间只有一个进程可以对共享内存进行写操纵。
五、消息队列

5.1 消息队列的特点

添加消息和读取消息是消息队列的根本操纵。消息是一个布局体，布局体名字由自己定义，特殊的地方是第一个成员是长整型（代表消息的类型），且该类型的值至少为1。
为什么消息类型必须大于零？

长整型如果是0号，就是不区分消息类型，在函数调用中，要是传入0的话，无论是什么消息类型都能读到。这样可以根据差别的消息类型对消息进行分类处理，提高消息处理的灵活性和效率。
5.2 消息队列的接口函数

• msgget()：创建或获取消息队列。
  

1. int msgget(key_t key, int msgflg);

复制代码

key是消息队列的键值，用于唯一标识一个消息队列；msgflg是标志位，用于指定创建方式和权限等。

• msgrcv()：读取消息。
  

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

复制代码

msqid是消息队列的标识符；msgp是用于存储接收到的消息的缓冲区；msgsz是缓冲区的大小；msgtyp是盼望接收的消息类型；msgflg是标志位，用于指定操纵方式。

• msgsnd()：发送消息。
  

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

复制代码

参数寄义与msgrcv类似。
5.3 示例

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/msg.h>
7. struct mess
8. {
9.     long type;
10.     char buff[128];
11. };
13. int main()
14. {
15.     int msgid = msgget((key_t)1234, IPC_CREAT | 0600);
16.     if (msgid == -1)
17.     {
18.         perror("msgget");
19.         exit(1);
20.     }
21.     struct mess m;
22.     m.type = 1;
23.     strcpy(m.buff, "hello");
25.     if (msgsnd(msgid, &m, sizeof(m.buff), 0) == -1)
26.     {
27.         perror("msgsnd");
28.         exit(1);
29.     }
30.     exit(0);
31. }

复制代码

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <sys/msg.h>
7. struct mess
8. {
9.     long type;
10.     char buff[128];
11. };
13. int main()
14. {
15.     int msgid = msgget((key_t)1234, IPC_CREAT | 0600);
16.     if (msgid == -1)
17.     {
18.         perror("msgget");
19.         exit(1);
20.     }
21.     struct mess m;
22.     if (msgrcv(msgid, &m, sizeof(m.buff), 1, 0) == -1)
23.     {
24.         perror("msgrcv");
25.         exit(1);
26.     }
27.     printf("read:%s\n", m.buff);
28.     exit(0);
29. }

复制代码

思考题目9：消息队列的大小有限制吗？如果消息队列满了会怎样？

消息队列的大小是有限制的，差别的系统大概有差别的默认值。当消息队列满了时，后续的msgsnd操纵会阻塞，直到队列中有空间可以容纳新的消息。这是为了防止消息队列溢出，保证消息的有序存储和处理。
思考题目10：消息队列在分布式系统中有哪些应用场景？

在分布式系统中，消息队列可以用于异步通讯、任务调度、解耦服务等场景。比方，在一个电商系统中，订单服务在处理订单时可以将订单信息发送到消息队列中，库存服务、物流服务等可以从消息队列中获取订单信息并进行相应的处理，这样可以提高系统的并发处理本领和可扩展性。
六、IPC管理命令

6.1 ipcs

ipcs命令可以检察消息队列、共享内存、信号量的利用环境。比方：

• ipcs -m：检察共享内存的利用信息。
  
• ipcs -q：检察消息队列的利用信息。
  
• ipcs -s：检察信号量的利用信息。
  

6.2 ipcrm

利用ipcrm命令可以进行删除操纵。手动移除的命令格式为ipcrm -s/m/q +id，分别用于删除信号量、共享内存、消息队列。比方：

• ipcrm -m 1234：删除ID为1234的共享内存段。
  
• ipcrm -q 5678：删除ID为5678的消息队列。
  
• ipcrm -s 9012：删除ID为9012的信号量集。
  

通过这些命令，系统管理员可以方便地管理系统中的IPC资源，确保系统的稳固运行。
思考题目11：在利用ipcrm命令删除IPC资源时必要注意什么？

在利用ipcrm命令删除IPC资源时，必要确保该资源不再被其他进程利用。如果在其他进程还在利用该资源时删除，大概会导致这些进程出现异常，甚至崩溃。因此，在删除之前，必要先确认相干进程已经停止利用该资源，或者采取适当的同步机制来确保安全删除。
思考题目12：怎样定期清算系统中的IPC资源，以制止资源浪费？

可以编写脚本，结合ipcs命令检察IPC资源的利用环境，根据一定的规则（如资源的利用时间、是否有进程关联等）筛选出不再利用的资源，然后利用ipcrm命令进行删除。还可以设置定时任务，定期执行该脚本，以确保系统中的IPC资源得到及时清算。

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