ChoChoX/obsidian
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vault backup: 2026-06-14 19:05:57

Browse Source
This commit is contained in:
ChoChoX
2026-06-14 19:05:57 +08:00
parent 224c3dc574
commit 8197fd341e
4 changed files with 1895 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

628
操作系统/操作系统实践/实践02_多进程多线程服务器.md Normal file
View File

@@ -0,0 +1,628 @@
# 实践02：Web服务器的多进程与多线程模型实现
> [!info] 实验信息
> **课程**：操作系统实践
> **实验名称**：实验二 — Web服务器的多进程与多线程模型实现
> **前置实验**：[[实践01_Web服务器初步实现]]
## 实验目的
1. 将 Web 服务器改造为多进程、多线程、预线程、线程池四种版本
2. 掌握并行网络服务器的设计方法
3. 使用 `http_load` 进行性能测试与对比分析
4. 理解不同并发模型的优劣及适用场景
> [!tip] 关联理论课程
> - [[06_进程控制]] — `fork`、信号处理、僵尸进程回收
> - [[07_多线程编程]] — `pthread_create`、线程同步
> - [[10_并发服务器]] — 并发模型概述与对比
---
## 源代码文件清单
> [!note] 本次实验新增文件（在实验一基础上）
> | 文件 | 说明 |
> |------|------|
> | `togglesp.c` | 多进程 toggle 服务器 |
> | `togglest.c` | 多线程 toggle 服务器 |
> | `togglest_pre.c` | 预线程 toggle 服务器 |
> | `togglest_pool.c` | 线程池 toggle 服务器 |
---
## 一、四种并发模型总览
### 模型架构图
```mermaid
graph TD
subgraph "模型一：多进程 Process-per-Connection"
C1[客户端 1] -->|accept| S1[主进程]
S1 -->|fork| P1[子进程 1]
S1 -->|fork| P2[子进程 2]
S1 -->|fork| P3[子进程 3]
P1 --> R1[处理请求]
P2 --> R2[处理请求]
P3 --> R3[处理请求]
end
```
```mermaid
graph TD
subgraph "模型二：多线程 Thread-per-Connection"
C2[客户端] -->|accept| SM[主线程]
SM -->|pthread_create| T1[线程 1]
SM -->|pthread_create| T2[线程 2]
SM -->|pthread_create| T3[线程 3]
T1 --> H1[处理请求]
T2 --> H2[处理请求]
T3 --> H3[处理请求]
end
```
```mermaid
graph TD
subgraph "模型三：预线程 Pre-threaded"
C3[客户端] -->|accept| PM[主线程]
PM -->|放入任务队列| Q[(任务队列)]
Q -->|取任务| W1[工作线程 1]
Q -->|取任务| W2[工作线程 2]
Q -->|取任务| W3[工作线程 3]
Q -->|取任务| W4[工作线程 N]
end
```
```mermaid
graph TD
subgraph "模型四：线程池 Thread Pool"
C4[客户端] -->|submit| POOL[线程池管理器]
POOL -->|dispatch| Q2[(任务队列)]
Q2 -->|worker| WT1[工作线程 1]
Q2 -->|worker| WT2[工作线程 2]
Q2 -->|worker| WT3[工作线程 N]
WT1 -->|完成| POOL
WT2 -->|完成| POOL
end
```
### 四种模型对比
| 模型 | 源文件 | 创建时机 | 优点 | 缺点 |
|------|--------|----------|------|------|
| 多进程 | `togglesp.c` | 按需 `fork` | 简单、进程隔离 | `fork` 开销大 |
| 多线程 | `togglest.c` | 按需 `pthread_create` | 比 `fork` 轻量 | 线程创建仍有开销 |
| 预线程 | `togglest_pre.c` | 启动时创建线程池 | 无运行时创建开销 | 需要任务队列同步 |
| 线程池 | `togglest_pool.c` | 启动时创建线程池 | 最优性能、可复用 | 实现复杂度最高 |
---
## 二、任务一：验证 Toggle 服务器的四种版本
### 2.1 编译
```bash
# 多进程版本
gcc -o togglesp togglesp.c csapp.c -lpthread
# 多线程版本
gcc -o togglest togglest.c csapp.c -lpthread
# 预线程版本
gcc -o togglest_pre togglest_pre.c csapp.c -lpthread
# 线程池版本
gcc -o togglest_pool togglest_pool.c csapp.c -lpthread
```
### 2.2 分别运行与测试
```bash
# ---- 测试多进程版本 ----
./togglesp 8080 &
./togglec localhost 8080
# 输入: Hello World
# 输出: hELLO wORLD
# ---- 测试多线程版本 ----
./togglest 8081 &
./togglec localhost 8081
# ---- 测试预线程版本 ----
./togglest_pre 8082 &
./togglec localhost 8082
# ---- 测试线程池版本 ----
./togglest_pool 8083 &
./togglec localhost 8083
```
> [!warning] 注意
> 测试前确保端口未被占用，可用 `lsof -i:8080` 或 `netstat -tlnp` 检查。
---
## 三、多进程模型详解 — togglesp.c
### 3.1 整体流程
```mermaid
sequenceDiagram
participant Main as 主进程
participant Child as 子进程
participant Client as 客户端
Main->>Main: Signal(SIGCHLD, handler)
Main->>Main: listen_sock = open_listen_sock(port)
loop 持续接受连接
Main->>Main: conn_sock = accept(...)
Main->>Main: fork()
alt 子进程
Main->>Child: 进入子进程
Child->>Main: close(listen_sock)
Child->>Client: toggle(conn_sock, hit)
Child->>Child: exit(0)
else 父进程
Main->>Main: close(conn_sock)
end
end
```
### 3.2 核心代码解析
#### 信号处理：回收僵尸进程
```c
void sigchld_handler(int sig) {
while (waitpid(-1, 0, WNOHANG) > 0);
// WNOHANG: 非阻塞，避免信号处理函数中阻塞
// while 循环: 一次回收所有已终止的子进程（防止信号丢失）
}
```
> [!important] 为什么用 `while` 循环？
> Unix 信号不排队。如果两个子进程几乎同时终止，可能只收到一次 `SIGCHLD`。循环调用 `waitpid` 确保所有僵尸进程都被回收。
#### toggle 函数：大小写转换
```c
void toggle(int conn_sock, int hit) {
int n;
char buf[MAXLINE];
while ((n = recv(conn_sock, buf, MAXLINE, 0)) > 0) {
// 逐字节进行大小写转换
for (int i = 0; i < n; i++) {
if (isupper(buf[i]))
buf[i] = tolower(buf[i]);
else if (islower(buf[i]))
buf[i] = toupper(buf[i]);
}
send(conn_sock, buf, n, 0); // 原样发回转换后的数据
}
}
```
#### 主循环：fork 并发处理
```c
int main(int argc, char **argv) {
int listen_sock, conn_sock, hit;
socklen_t clientlen;
struct sockaddr_storage clientaddr;
Signal(SIGCHLD, sigchld_handler); // 注册 SIGCHLD 处理函数
listen_sock = open_listen_sock(argv[1]); // 创建监听套接字
for (hit = 1; ; hit++) {
clientlen = sizeof(clientaddr);
conn_sock = accept(listen_sock,
(SA *)&clientaddr, &clientlen);
if (Fork() == 0) { // 子进程
close(listen_sock); // 关闭监听套接字（子进程不需要）
toggle(conn_sock, hit); // 处理请求
close(conn_sock); // 关闭连接套接字
exit(0); // 子进程退出
}
close(conn_sock); // 父进程关闭连接套接字
}
}
```
> [!note] 父子进程的套接字处理
> - **父进程**：`close(conn_sock)` — 父进程不处理该连接
> - **子进程**：`close(listen_sock)` — 子进程不接受新连接
> - 这是多进程服务器的标准模式，避免文件描述符泄漏
### 3.3 多进程模型的优缺点
```
优点 缺点
+----------------------------------+----------------------------------+
| 进程间地址空间隔离 | fork() 系统调用开销大 |
| 一个进程崩溃不影响其他进程 | 每个进程占用独立内存空间 |
| 编程模型简单直观 | 进程数受系统限制 |
| 天然线程安全（无共享数据） | 上下文切换开销大 |
+----------------------------------+----------------------------------+
```
---
## 四、多线程模型详解 — togglest.c
### 4.1 核心结构
```c
// 线程参数结构体
typedef struct {
int conn_sock;
int hit;
} thread_args_t;
void *thread_toggle(void *vargp) {
thread_args_t *args = (thread_args_t *)vargp;
int conn_sock = args->conn_sock;
int hit = args->hit;
Free(vargp); // 释放参数内存
toggle(conn_sock, hit); // 处理请求（复用 toggle 函数）
Close(conn_sock); // 关闭连接
return NULL;
}
int main(int argc, char **argv) {
listen_sock = open_listen_sock(port);
for (hit = 1; ; hit++) {
conn_sock = accept(listen_sock, ...);
// 为每个连接分配参数
thread_args_t *args = Malloc(sizeof(thread_args_t));
args->conn_sock = conn_sock;
args->hit = hit;
// 创建分离线程（自动回收，无需 join）
Pthread_create(&tid, NULL, thread_toggle, args);
}
}
```
> [!tip] 为什么要用 `pthread_detach`？
> 如果不分离线程，线程终止后其资源不会自动释放，造成资源泄漏（类似僵尸进程）。使用 `pthread_detach` 或 `pthread_create` 后立即 `pthread_detach` 可避免此问题。
### 4.2 多线程 vs 多进程
```mermaid
graph LR
subgraph 多进程
A1[主进程] -->|fork| A2[子进程]
A2 -->|独立地址空间| A3[处理请求]
end
subgraph 多线程
B1[主线程] -->|pthread_create| B2[新线程]
B2 -->|共享地址空间| B3[处理请求]
end
style A1 fill:#ffcdd2
style A2 fill:#ffcdd2
style A3 fill:#ffcdd2
style B1 fill:#c8e6c9
style B2 fill:#c8e6c9
style B3 fill:#c8e6c9
```
---
## 五、预线程模型详解 — togglest_pre.c
### 5.1 设计思想
预线程模型在服务器启动时就创建固定数量的工作线程，所有线程共享一个任务队列，形成**生产者-消费者**模型。
```mermaid
graph LR
P[主线程/生产者] -->|sbuf_insert| Q[(共享任务队列<br/>conn_sock)]
Q -->|sbuf_remove| W1[工作线程 1]
Q -->|sbuf_remove| W2[工作线程 2]
Q -->|sbuf_remove| W3[工作线程 3]
Q -->|sbuf_remove| WN[工作线程 N]
style P fill:#bbdefb
style Q fill:#fff9c4
style W1 fill:#c8e6c9
style W2 fill:#c8e6c9
style W3 fill:#c8e6c9
style WN fill:#c8e6c9
```
### 5.2 核心代码解析
#### Sbuf：带信号量的共享缓冲区
```c
typedef struct {
int *buf; // 缓冲区数组
int n; // 缓冲区容量
int front; // 队头索引
int rear; // 队尾索引
sem_t mutex; // 互斥信号量
sem_t slots; // 空槽数量信号量
sem_t items; // 已有项目数信号量
} sbuf_t;
void sbuf_insert(sbuf_t *sp, int item) {
P(&sp->slots); // 等待空槽
P(&sp->mutex); // 加锁
sp->buf[(++sp->rear) % sp->n] = item; // 入队
V(&sp->mutex); // 解锁
V(&sp->items); // 增加项目数
}
int sbuf_remove(sbuf_t *sp) {
P(&sp->items); // 等待有项目
P(&sp->mutex); // 加锁
int item = sp->buf[(++sp->front) % sp->n]; // 出队
V(&sp->mutex); // 解锁
V(&sp->slots); // 增加空槽数
return item;
}
```
> [!important] 信号量的顺序不能颠倒！
> `sbuf_insert` 中先 `P(slots)` 再 `P(mutex)`，如果反过来，可能导致死锁：线程持有 mutex 但等待 slots，而其他线程无法获取 mutex 来释放 slots。
#### 工作线程函数
```c
void *thread_toggle(void *vargp) {
sbuf_t *sp = (sbuf_t *)vargp;
Pthread_detach(pthread_self());
while (1) {
int conn_sock = sbuf_remove(sp); // 阻塞等待任务
toggle(conn_sock, -1); // 处理请求
Close(conn_sock); // 关闭连接
}
return NULL;
}
int main(int argc, char **argv) {
sbuf_t sbuf;
sbuf_init(&sbuf, SBUFSIZE); // 初始化缓冲区
// 启动时创建 N 个工作线程
for (int i = 0; i < NTHREADS; i++)
Pthread_create(&tid, NULL, thread_toggle, &sbuf);
listen_sock = open_listen_sock(port);
while (1) {
conn_sock = accept(listen_sock, ...);
sbuf_insert(&sbuf, conn_sock); // 主线程生产
}
}
```
### 5.3 预线程模型的优势
```
传统模型（按需创建） 预线程模型（预先创建）
accept --> fork/create accept --> 入队
| |
+--> [创建开销] --> 处理 +--> [零开销] --> 工作线程直接处理
```
- **消除运行时创建开销**：线程在启动时一次性创建完毕
- **控制并发度**：线程数固定，避免系统过载
- **生产者-消费者解耦**：主线程只负责 accept，工作线程只负责处理
---
## 六、任务二~四：将 Toggle 服务器改造为 Weblet 服务器
### 6.1 改造思路
Toggle 服务器的核心逻辑是**大小写转换**，Weblet 服务器的核心逻辑是**HTTP 请求解析与响应**。改造的关键在于将 `toggle()` 函数替换为 HTTP 处理逻辑。
```mermaid
graph TD
A[Toggle 服务器] -->|替换核心处理函数| B[Weblet 服务器]
A --> A1["toggle(): 大小写转换"]
B --> B1["doit(): HTTP 请求处理"]
B1 --> B2[解析请求行 GET /path HTTP/1.1]
B1 --> B3[解析请求头]
B1 --> B4[构建响应: 静态/动态内容]
B1 --> B5[发送响应给客户端]
```
### 6.2 多进程 Weblet
```c
// 仿照 togglesp.c 的结构
void sigchld_handler(int sig) {
while (waitpid(-1, 0, WNOHANG) > 0);
}
int main(int argc, char **argv) {
Signal(SIGCHLD, sigchld_handler);
listen_sock = open_listen_sock(port);
for (hit = 1; ; hit++) {
conn_sock = accept(listen_sock, ...);
if (Fork() == 0) {
close(listen_sock);
doit(conn_sock, hit); // 替换为 HTTP 处理
close(conn_sock);
exit(0);
}
close(conn_sock);
}
}
```
### 6.3 多线程 Weblet
```c
// 仿照 togglest.c 的结构
void *thread_doit(void *vargp) {
int conn_sock = *((int *)vargp);
Free(vargp);
Pthread_detach(pthread_self());
doit(conn_sock, -1); // HTTP 处理
Close(conn_sock);
return NULL;
}
int main(int argc, char **argv) {
listen_sock = open_listen_sock(port);
while (1) {
clientlen = sizeof(clientaddr);
conn_sock = accept(listen_sock, ...);
int *fdp = Malloc(sizeof(int));
*fdp = conn_sock;
Pthread_create(&tid, NULL, thread_doit, fdp);
}
}
```
### 6.4 预线程 Weblet
```c
// 仿照 togglest_pre.c 的结构
void *thread_doit(void *vargp) {
sbuf_t *sp = (sbuf_t *)vargp;
Pthread_detach(pthread_self());
while (1) {
int conn_sock = sbuf_remove(sp);
doit(conn_sock, -1); // HTTP 处理
Close(conn_sock);
}
}
int main(int argc, char **argv) {
sbuf_t sbuf;
sbuf_init(&sbuf, SBUFSIZE);
for (int i = 0; i < NTHREADS; i++)
Pthread_create(&tid, NULL, thread_doit, &sbuf);
listen_sock = open_listen_sock(port);
while (1) {
conn_sock = accept(listen_sock, ...);
sbuf_insert(&sbuf, conn_sock);
}
}
```
---
## 七、任务五：性能对比测试（http_load）
### 7.1 测试方法
```bash
# 生成 URL 文件
echo "http://localhost:8080/index.html" > urls.txt
# 使用 http_load 进行压力测试
# -p 并发数，-s 测试时间（秒）
http_load -p 10 -s 10 urls.txt # 10 并发，持续 10 秒
http_load -p 50 -s 10 urls.txt # 50 并发，持续 10 秒
http_load -p 100 -s 10 urls.txt # 100 并发，持续 10 秒
http_load -p 200 -s 10 urls.txt # 200 并发，持续 10 秒
```
### 7.2 测试结果记录模板
| 并发数 | 多进程 (req/s) | 多线程 (req/s) | 预线程 (req/s) | 线程池 (req/s) |
|--------|---------------|---------------|---------------|---------------|
| 10 | | | | |
| 50 | | | | |
| 100 | | | | |
| 200 | | | | |
### 7.3 预期结论
> [!abstract] 性能排序
> **线程池 >= 预线程 > 多线程 > 多进程**
>
> - **多进程**：`fork()` 开销随并发数增加显著上升
> - **多线程**：`pthread_create` 比 `fork` 轻量，但仍有创建开销
> - **预线程**：启动时创建线程池，运行时零创建开销
> - **线程池**：在预线程基础上增加了线程复用和动态管理
---
## 八、关键知识点总结
### fork 与 pthread_create 的对比
| 特性 | fork (多进程) | pthread_create (多线程) |
|------|--------------|------------------------|
| 地址空间 | 复制（写时复制） | 共享 |
| 创建开销 | 大（页表复制） | 较小 |
| 通信方式 | 进程间通信（管道等） | 直接共享内存 |
| 崩溃隔离 | 互相隔离 | 一个线程崩溃可能影响全部 |
| 文件描述符 | 复制 | 共享 |
| 信号处理 | 各进程独立 | 需要协调 |
### 信号量在生产者-消费者中的应用
```mermaid
sequenceDiagram
participant P as 生产者（主线程）
participant M as mutex
participant S as slots 信号量
participant I as items 信号量
participant C as 消费者（工作线程）
P->>S: P(slots) — 等待空槽
P->>M: P(mutex) — 加锁
P->>P: 插入任务到队列
P->>M: V(mutex) — 解锁
P->>I: V(items) — 通知有新任务
C->>I: P(items) — 等待任务
C->>M: P(mutex) — 加锁
C->>C: 从队列取出任务
C->>M: V(mutex) — 解锁
C->>S: V(slots) — 释放空槽
C->>C: 处理请求
```
---
## 常见问题
> [!failure] 问题：多进程版本出现僵尸进程
> **原因**：未正确处理 `SIGCHLD` 信号，或信号处理函数中未使用 `WNOHANG` 循环回收。
> **解决**：确保 `sigchld_handler` 中使用 `while (waitpid(-1, 0, WNOHANG) > 0);`
> [!failure] 问题：多线程版本出现段错误（Segmentation Fault）
> **原因**：传递给线程的参数在主线程中被覆盖。
> **解决**：为每个线程 `malloc` 独立的参数结构体，不要传递局部变量的地址。
> [!failure] 问题：预线程版本程序卡死不响应
> **原因**：信号量使用顺序错误导致死锁。
> **解决**：`sbuf_insert` 中先 `P(slots)` 后 `P(mutex)`；`sbuf_remove` 中先 `P(items)` 后 `P(mutex)`。
---
## 扩展阅读
- [[06_进程控制]] — fork、waitpid、信号处理详细原理
- [[07_多线程编程]] — pthread 线程编程详解
- [[10_并发服务器]] — 三种并发模型的理论对比
- [[实践01_Web服务器初步实现]] — 实验一基础 Web 服务器