396 lines
10 KiB
Markdown
396 lines
10 KiB
Markdown
# 第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)
|