# 实践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 服务器