vault backup: 2026-06-13 23:46:22

2026-06-13 23:46:22 +08:00
parent 9a3d58dd3b
commit 224c3dc574
33 changed files with 14997 additions and 0 deletions
--- a/操作系统/08_进程间通信/08_进程间通信.md
+++ b/操作系统/08_进程间通信/08_进程间通信.md
@@ -0,0 +1,406 @@
+# 第08讲：进程间通信
+
+> 🎯 **本节目标**：掌握管道、消息队列、共享内存等进程间通信方式
+
+## 📋 前置知识
+- [[06_进程控制]] — 进程的基本概念
+- [[06_进程控制_深入]] — fork 和 exec 的工作原理
+
+---
+
+## 🤔 为什么需要这个？
+
+进程之间是相互隔离的，每个进程有自己的地址空间。但有时候进程需要协作：
+- Shell 需要将 `ls` 的输出传给 `grep`
+- 浏览器需要与下载管理器通信
+- 数据库需要与应用程序交互
+
+**进程间通信（IPC）** 就是解决这个问题的。
+
+**生活比喻**：
+- **管道** = 对讲机（单向通信）
+- **消息队列** = 邮箱（异步通信）
+- **共享内存** = 共享白板（最快的通信方式）
+
+---
+
+## 📖 核心概念
+
+### 1. IPC 方式概览
+
+```mermaid
+graph TD
+    A[进程间通信 IPC] --> B[管道 Pipe]
+    A --> C[消息队列 Message Queue]
+    A --> D[共享内存 Shared Memory]
+    A --> E[信号 Signal]
+    A --> F[信号量 Semaphore]
+    A --> G[套接字 Socket]
+
+    B --> B1[单向通信]
+    C --> C1[异步通信]
+    D --> D1[最快]
+    E --> E1[异步通知]
+    F --> F1[同步控制]
+    G --> G1[网络通信]
+
+    style A fill:#e1f5fe
+    style D fill:#e8f5e9
+```
+
+**对比**：
+| 方式 | 优点 | 缺点 | 适用场景 |
+|------|------|------|----------|
+| 管道 | 简单、易用 | 单向、只能父子进程 | Shell 命令组合 |
+| 消息队列 | 异步、可按类型读取 | 有大小限制 | 任务分发 |
+| 共享内存 | 最快 | 需要同步机制 | 大量数据交换 |
+| 信号 | 异步通知 | 只能传递信号编号 | 事件通知 |
+| 信号量 | 同步控制 | 不能传递数据 | 互斥、同步 |
+| 套接字 | 跨网络 | 开销大 | 网络通信 |
+
+### 2. 管道（Pipe）
+
+管道是最古老的 IPC 方式，用于有亲缘关系的进程之间：
+
+```mermaid
+graph LR
+    A[写端 fd[1]] -->|数据流| B[读端 fd[0]]
+
+    style A fill:#e8f5e9
+    style B fill:#e1f5fe
+```
+
+**特点**：
+- **单向**：只能从一端写，另一端读
+- **有亲缘关系**：通常用于父子进程
+- **自带同步**：读端空时阻塞，写端满时阻塞
+
+### 3. 命名管道（FIFO）
+
+命名管道让没有亲缘关系的进程也能通信：
+
+```mermaid
+graph LR
+    A[进程1] -->|写入| B[/tmp/my_fifo]
+    B -->|读取| C[进程2]
+
+    style B fill:#fff3e0
+```
+
+**特点**：
+- 有文件名，存在于文件系统中
+- 任意进程都可以打开
+- 使用方法与普通文件相同
+
+### 4. 消息队列
+
+消息队列是一种异步通信方式：
+
+```mermaid
+graph LR
+    A[发送方 msgsnd] -->|消息| B[消息队列]
+    B -->|消息| C[接收方 msgrcv]
+
+    style B fill:#fff3e0
+```
+
+**消息结构**：
+```c
+struct msgbuf {
+    long mtype;      // 消息类型
+    char mtext[512]; // 消息内容
+};
+```
+
+**优势**：
+- 可以按类型读取消息
+- 异步通信，不需要同步
+- 可以设置优先级
+
+### 5. 共享内存
+
+共享内存是最快的 IPC 方式：
+
+```mermaid
+graph TD
+    A[进程1] -->|读写| B[共享内存区域]
+    C[进程2] -->|读写| B
+
+    style B fill:#e8f5e9
+```
+
+**工作流程**：
+1. 创建共享内存段
+2. 将共享内存映射到进程地址空间
+3. 直接读写共享内存
+4. 使用完毕后分离
+
+**注意**：共享内存本身不提供同步机制，需要配合信号量使用。
+
+---
+
+## 💻 动手实践
+
+### 示例1：使用管道通信
+
+```c
+// pipe1.c - 管道通信示例
+#include "wrapper.h"
+
+int main() {
+    int count;
+    int fds[2];  // fds[0]=读端, fds[1]=写端
+    const char some_data[] = "1234567890";
+    char buffer[BUFSIZ + 1];
+
+    memset(buffer, '\0', sizeof(buffer));
+
+    // 创建管道
+    pipe(fds);
+
+    // 向管道写入数据
+    count = Write(fds[1], (void *)some_data, strlen(some_data));
+    printf("Wrote %d bytes\n", count);
+
+    // 从管道读取数据
+    count = Read(fds[0], (void *)buffer, BUFSIZ);
+    printf("Read %d bytes: %s\n", count, buffer);
+
+    exit(EXIT_SUCCESS);
+}
+```
+
+**编译运行**：
+```bash
+gcc -o pipe1 pipe1.c -L. -lwrapper
+./pipe1
+```
+
+**预期输出**：
+```
+Wrote 10 bytes
+Read 10 bytes: 1234567890
+```
+
+### 示例2：创建命名管道
+
+```c
+// fifo1.c - 创建命名管道
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+int main() {
+    int res = mkfifo("/tmp/my_fifo", 0777);
+    if (res == 0)
+        printf("FIFO created\n");
+    exit(EXIT_SUCCESS);
+}
+```
+
+**编译运行**：
+```bash
+gcc -o fifo1 fifo1.c
+./fifo1
+ls -l /tmp/my_fifo
+```
+
+**使用命名管道**：
+```bash
+# 终端1：写入数据
+echo "Hello FIFO" > /tmp/my_fifo
+
+# 终端2：读取数据
+cat /tmp/my_fifo
+```
+
+### 示例3：共享内存通信
+
+```c
+// shmwrite.c - 写入共享内存
+#include "wrapper.h"
+
+int main(int argc, char *argv[]) {
+    int shmid;
+    key_t key;
+    void *shmptr;
+
+    if (argc <= 1) {
+        fprintf(stderr, "请以 ./shmwrite <key> <message> 形式运行\n");
+        exit(2);
+    }
+
+    // 将参数转换成十六进制数作为 key
+    sscanf(argv[1], "%x", &key);
+
+    // 创建共享内存
+    shmid = Shmget(key, 4096, IPC_CREAT | 0644);
+
+    // 将共享内存映射到进程地址空间
+    shmptr = Shmat(shmid, 0, 0);
+
+    // 写入数据
+    memcpy(shmptr, argv[2], strlen(argv[2]) + 1);
+
+    // 分离共享内存
+    Shmdt(shmptr);
+    exit(0);
+}
+```
+
+```c
+// shmread.c - 读取共享内存
+#include "wrapper.h"
+
+int main(int argc, char *argv[]) {
+    int shmid;
+    key_t key;
+    void *shmptr;
+
+    if (argc <= 1) {
+        fprintf(stderr, "请以 ./shmread <key> 形式运行\n");
+        exit(2);
+    }
+
+    sscanf(argv[1], "%x", &key);
+
+    // 获取已存在的共享内存
+    shmid = Shmget(key, 4096, IPC_CREAT | 0644);
+
+    // 映射共享内存
+    shmptr = Shmat(shmid, 0, 0);
+
+    // 读取数据
+    printf("%s\n", (char *)shmptr);
+
+    // 分离共享内存
+    Shmdt(shmptr);
+    exit(0);
+}
+```
+
+**编译运行**：
+```bash
+gcc -o shmwrite shmwrite.c -L. -lwrapper
+gcc -o shmread shmread.c -L. -lwrapper
+
+# 写入数据
+./shmwrite 0x12345678 "Hello Shared Memory!"
+
+# 读取数据
+./shmread 0x12345678
+```
+
+**预期输出**：
+```
+Hello Shared Memory!
+```
+
+### 示例4：消息队列通信
+
+```c
+// msgsnd1.c - 发送消息
+#include "wrapper.h"
+
+typedef struct MESSAGE {
+    int mtype;
+    char mtext[512];
+} mymsg, *pmymsg;
+
+int main(int argc, char *argv[]) {
+    int msqid;
+    key_t key;
+    mymsg msginfo;
+
+    if (argc != 3) {
+        fprintf(stderr, "使用方法: msgsnd1 <key> <message>\n");
+        exit(2);
+    }
+
+    sscanf(argv[1], "%x", &key);
+
+    // 获取消息队列
+    msqid = Msgget(key, 0644);
+
+    // 设置消息类型和内容
+    msginfo.mtype = 1;
+    memcpy(&msginfo.mtext, argv[2], strlen(argv[2]) + 1);
+
+    // 发送消息
+    Msgsnd(msqid, (pmymsg)&msginfo, strlen(msginfo.mtext) + 1, 0);
+    printf("you send a message \"%s\" to msq %d\n", argv[1], msqid);
+    return 0;
+}
+```
+
+```c
+// msgrcv1.c - 接收消息
+#include "wrapper.h"
+
+typedef struct MESSAGE {
+    int mtype;
+    char mtext[512];
+} mymsg, *pmymsg;
+
+int main(int argc, char *argv[]) {
+    int msqid;
+    key_t key;
+    mymsg msginfo;
+
+    if (argc != 2) {
+        fprintf(stderr, "使用方法: msgrcv1 <key>\n");
+        exit(2);
+    }
+
+    sscanf(argv[1], "%x", &key);
+
+    // 获取消息队列
+    msqid = Msgget(key, 0644);
+
+    // 接收消息（类型为1）
+    msgrcv(msqid, (pmymsg)&msginfo, 512, 1, 0);
+    printf("%s\n", msginfo.mtext);
+    return 0;
+}
+```
+
+**编译运行**：
+```bash
+gcc -o msgsnd1 msgsnd1.c -L. -lwrapper
+gcc -o msgrcv1 msgrcv1.c -L. -lwrapper
+
+# 发送消息
+./msgsnd1 0x12345678 "Hello Message Queue!"
+
+# 接收消息
+./msgrcv1 0x12345678
+```
+
+**预期输出**：
+```
+Hello Message Queue!
+```
+
+---
+
+## 🔗 知识关联
+- 管道在 Shell 中广泛使用，详见 [[06_进程控制_深入]]
+- 共享内存的同步需要信号量，详见 [[07_多线程编程]]
+- 套接字是网络通信的基础，详见 [[09_网络编程]]
+
+---
+
+## 📝 思考题
+
+1. **管道的局限性**：为什么管道只能用于有亲缘关系的进程？
+2. **共享内存的速度优势**：为什么共享内存比管道快？
+3. **消息队列 vs 管道**：在什么场景下消息队列比管道更合适？
+
+---
+
+## 📚 扩展阅读
+- 《UNIX环境高级编程》第15章：进程间通信
+- 《深入理解计算机系统》第10章：系统级I/O
+- [Linux IPC 编程](https://www.tldp.org/LDP/tlk/ipc/ipc.html)