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/操作系统/10_并发服务器/10_并发服务器.md
+++ b/操作系统/10_并发服务器/10_并发服务器.md
@@ -0,0 +1,395 @@
+# 第10讲：并发网络服务器
+
+> 🎯 **本节目标**：掌握多进程、多线程、I/O 多路复用三种并发服务器模型
+
+## 📋 前置知识
+- [[09_网络编程]] — Socket 编程基础
+- [[06_进程控制]] — 进程创建
+- [[07_多线程编程]] — 线程创建
+
+---
+
+## 🤔 为什么需要这个？
+
+上一讲的服务器一次只能服务一个客户端。如果有 100 个用户同时访问网站，第 100 个用户必须等前 99 个都处理完才能得到响应。
+
+**并发服务器**就是解决这个问题的——让服务器能够同时服务多个客户端。
+
+**生活比喻**：
+- **迭代服务器** = 一个服务员一次只服务一桌客人
+- **多进程服务器** = 每来一桌客人就招一个新服务员
+- **多线程服务器** = 一个服务员同时照看多桌客人
+- **I/O 多路复用** = 服务员轮流查看哪桌客人需要服务
+
+---
+
+## 📖 核心概念
+
+### 1. 三种并发模型
+
+```mermaid
+graph TD
+    A[并发服务器模型] --> B[多进程模型]
+    A --> C[多线程模型]
+    A --> D[I/O 多路复用]
+
+    B --> B1[每连接一个进程]
+    B --> B2[进程间隔离]
+    B --> B3[开销大]
+
+    C --> C1[每连接一个线程]
+    C --> C2[共享内存]
+    C --> C3[开销较小]
+
+    D --> D1[单线程处理多连接]
+    D --> D2[select/poll/epoll]
+    D --> D3[开销最小]
+
+    style B fill:#ffcdd2
+    style C fill:#fff3e0
+    style D fill:#e8f5e9
+```
+
+**对比**：
+| 模型 | 优点 | 缺点 | 适用场景 |
+|------|------|------|----------|
+| 多进程 | 隔离性好 | 开销大 | 连接数少 |
+| 多线程 | 开销较小 | 需要同步 | 连接数中等 |
+| I/O 多路复用 | 开销最小 | 编程复杂 | 连接数多 |
+
+### 2. 多进程模型
+
+```mermaid
+sequenceDiagram
+    participant 主进程
+    participant 子进程1
+    participant 子进程2
+    participant 客户端
+
+    主进程->>主进程: accept() 等待连接
+    客户端->>主进程: 连接请求
+    主进程->>子进程1: fork() 创建子进程
+    子进程1->>客户端: 处理请求
+    主进程->>主进程: 继续 accept()
+
+    客户端->>主进程: 新连接请求
+    主进程->>子进程2: fork() 创建子进程
+    子进程2->>客户端: 处理请求
+```
+
+**特点**：
+- 每个连接一个独立进程
+- 进程间完全隔离
+- 进程创建和销毁开销大
+
+### 3. 多线程模型
+
+```mermaid
+sequenceDiagram
+    participant 主线程
+    participant 工作线程1
+    participant 工作线程2
+    participant 客户端
+
+    主线程->>主线程: accept() 等待连接
+    客户端->>主线程: 连接请求
+    主线程->>工作线程1: pthread_create()
+    工作线程1->>客户端: 处理请求
+    主线程->>主线程: 继续 accept()
+
+    客户端->>主线程: 新连接请求
+    主线程->>工作线程2: pthread_create()
+    工作线程2->>客户端: 处理请求
+```
+
+**特点**：
+- 每个连接一个线程
+- 线程共享进程资源
+- 需要注意线程安全
+
+### 4. I/O 多路复用（select）
+
+```mermaid
+graph TD
+    A[主循环] --> B[select 监听所有 fd]
+    B --> C{哪个 fd 就绪?}
+    C -->|监听套接字| D[accept 新连接]
+    C -->|客户端套接字| E[处理请求]
+    D --> A
+    E --> A
+
+    style B fill:#fff3e0
+```
+
+**select 的工作原理**：
+1. 将所有需要监听的文件描述符放入集合
+2. 调用 `select()` 等待任意一个就绪
+3. 遍历集合，处理就绪的描述符
+4. 重复步骤 1
+
+**fd_set 操作**：
+```c
+fd_set read_set;
+FD_ZERO(&read_set);           // 清空集合
+FD_SET(fd1, &read_set);       // 添加 fd1
+FD_SET(fd2, &read_set);       // 添加 fd2
+select(maxfd+1, &read_set, NULL, NULL, NULL);  // 等待
+if (FD_ISSET(fd1, &read_set)) // 检查 fd1 是否就绪
+    // 处理 fd1
+```
+
+### 5. 线程池模型
+
+```mermaid
+graph TD
+    A[主线程] -->|accept| B[任务队列]
+    B --> C[工作线程1]
+    B --> D[工作线程2]
+    B --> E[工作线程3]
+    C -->|处理完毕| B
+    D -->|处理完毕| B
+    E -->|处理完毕| B
+
+    style B fill:#fff3e0
+```
+
+**优势**：
+- 避免频繁创建销毁线程
+- 控制并发数量
+- 提高资源利用率
+
+---
+
+## 💻 动手实践
+
+### 示例1：多线程并发服务器
+
+```c
+// togglest.c - 多线程并发服务器
+#include "wrapper.h"
+
+void toggle(int conn_sock);
+void *serve_client(void *vargp);
+
+int main(int argc, char **argv) {
+    int listen_sock, conn_sock, port, *conn_sock_p;
+    struct sockaddr_in clientaddr;
+    struct hostent *hp;
+    char *haddrp;
+    socklen_t clientlen = sizeof(struct sockaddr_in);
+    pthread_t tid;
+
+    if (argc != 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        exit(1);
+    }
+    port = atoi(argv[1]);
+
+    listen_sock = open_listen_sock(port);
+
+    while (1) {
+        conn_sock_p = malloc(sizeof(int));
+        *conn_sock_p = accept(listen_sock, (SA *)&clientaddr, &clientlen);
+
+        // 获取客户端信息
+        hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
+                           sizeof(clientaddr.sin_addr.s_addr), AF_INET);
+        haddrp = inet_ntoa(clientaddr.sin_addr);
+        printf("server connected to %s (%s)\n", hp->h_name, haddrp);
+
+        // 创建新线程处理客户端
+        pthread_create(&tid, NULL, serve_client, conn_sock_p);
+    }
+}
+
+void *serve_client(void *vargp) {
+    int conn_sock = *((int *)vargp);
+    pthread_detach(pthread_self());  // 分离线程
+    free(vargp);
+    toggle(conn_sock);
+    close(conn_sock);
+    return NULL;
+}
+```
+
+**编译运行**：
+```bash
+gcc -o togglest togglest.c -L. -lwrapper -lpthread
+
+# 终端1：启动服务器
+./togglest 8080
+
+# 终端2-4：启动多个客户端
+./togglec localhost 8080
+```
+
+### 示例2：I/O 多路复用服务器
+
+```c
+// toggless1.c - select 多路复用服务器
+#include "wrapper.h"
+
+void toggle(int conn_sock);
+void read_input(void);
+
+int main(int argc, char **argv) {
+    int listen_sock, conn_sock, port;
+    socklen_t clientlen = sizeof(struct sockaddr_in);
+    struct sockaddr_in clientaddr;
+    fd_set read_set, ready_set;
+
+    if (argc != 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        exit(1);
+    }
+    port = atoi(argv[1]);
+    listen_sock = open_listen_sock(port);
+
+    // 初始化 fd_set
+    FD_ZERO(&read_set);
+    FD_SET(STDIN_FILENO, &read_set);  // 监听标准输入
+    FD_SET(listen_sock, &read_set);   // 监听套接字
+
+    while (1) {
+        ready_set = read_set;
+        select(listen_sock + 1, &ready_set, NULL, NULL, NULL);
+
+        // 检查标准输入
+        if (FD_ISSET(STDIN_FILENO, &ready_set))
+            read_input();
+
+        // 检查新连接
+        if (FD_ISSET(listen_sock, &ready_set)) {
+            conn_sock = accept(listen_sock, (SA *)&clientaddr, &clientlen);
+            toggle(conn_sock);
+            close(conn_sock);
+        }
+    }
+}
+
+void read_input(void) {
+    char buf[MAXLINE];
+    if (!fgets(buf, MAXLINE, stdin))
+        exit(0);
+    printf("%s", buf);
+}
+```
+
+### 示例3：连接池服务器
+
+```c
+// toggless2.c - 连接池服务器
+#include "wrapper.h"
+
+typedef struct {
+    int maxfd;
+    fd_set read_set;
+    fd_set ready_set;
+    int nready;
+    int maxi;
+    int client_sock[FD_SETSIZE];
+} sock_pool;
+
+void init_sock_pool(int listen_sock, sock_pool *pool);
+void add_sock(int conn_sock, sock_pool *pool);
+void serve_clients(sock_pool *pool);
+
+int main(int argc, char **argv) {
+    int listen_sock, conn_sock, port;
+    socklen_t clientlen = sizeof(struct sockaddr_in);
+    struct sockaddr_in clientaddr;
+    static sock_pool pool;
+
+    if (argc != 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        exit(1);
+    }
+    port = atoi(argv[1]);
+
+    listen_sock = open_listen_sock(port);
+    init_sock_pool(listen_sock, &pool);
+
+    while (1) {
+        pool.ready_set = pool.read_set;
+        pool.nready = select(pool.maxfd + 1, &pool.ready_set, NULL, NULL, NULL);
+
+        // 新连接
+        if (FD_ISSET(listen_sock, &pool.ready_set)) {
+            conn_sock = accept(listen_sock, (SA *)&clientaddr, &clientlen);
+            add_sock(conn_sock, &pool);
+        }
+
+        // 处理客户端请求
+        serve_clients(&pool);
+    }
+}
+
+void init_sock_pool(int listen_sock, sock_pool *p) {
+    int i;
+    p->maxi = -1;
+    for (i = 0; i < FD_SETSIZE; i++)
+        p->client_sock[i] = -1;
+    p->maxfd = listen_sock;
+    FD_ZERO(&p->read_set);
+    FD_SET(listen_sock, &p->read_set);
+}
+
+void add_sock(int conn_sock, sock_pool *p) {
+    int i;
+    p->nready--;
+    for (i = 0; i < FD_SETSIZE; i++)
+        if (p->client_sock[i] < 0) {
+            p->client_sock[i] = conn_sock;
+            FD_SET(conn_sock, &p->read_set);
+            if (conn_sock > p->maxfd)
+                p->maxfd = conn_sock;
+            if (i > p->maxi)
+                p->maxi = i;
+            break;
+        }
+    if (i == FD_SETSIZE)
+        perror("add_sock error: Too many clients");
+}
+
+void serve_clients(sock_pool *p) {
+    int i, conn_sock, n;
+    char buf[MAXLINE];
+
+    for (i = 0; (i <= p->maxi) && (p->nready > 0); i++) {
+        conn_sock = p->client_sock[i];
+        if ((conn_sock > 0) && (FD_ISSET(conn_sock, &p->ready_set))) {
+            p->nready--;
+            if ((n = recv(conn_sock, buf, MAXLINE, 0)) != 0) {
+                printf("Server received %d bytes on fd %d\n", n, conn_sock);
+                send(conn_sock, buf, n, 0);
+            } else {
+                close(conn_sock);
+                FD_CLR(conn_sock, &p->read_set);
+                p->client_sock[i] = -1;
+            }
+        }
+    }
+}
+```
+
+---
+
+## 🔗 知识关联
+- 多进程模型在 [[06_进程控制]] 中有详细讲解
+- 多线程模型在 [[07_多线程编程]] 中有详细讲解
+- I/O 多路复用在 [[17_IO系统]] 中有更深入的讨论
+
+---
+
+## 📝 思考题
+
+1. **为什么 select 有 FD_SETSIZE 限制？** 如何突破这个限制？
+2. **多进程 vs 多线程**：在什么情况下多进程比多线程更合适？
+3. **epoll 的优势**：为什么 Linux 推荐使用 epoll 而不是 select？
+
+---
+
+## 📚 扩展阅读
+- 《UNIX网络编程》第1卷：第6章、第16章
+- [epoll 详解](https://man7.org/linux/man-pages/man7/epoll.7.html)
+- [高性能网络编程](https://www.zhihu.com/question/28594409)