phase 5 part 5: cs algorithms, network-os, web-security topics with tested examples; all 43 stacks pass --strict

This commit is contained in:
Shikui Wang committed 2026-10-23 16:47:11 +08:00
1 parent f695bbd7cc
commit 691f738f5f
22 files changed
+1955 -37

No files matched your search

+101
View File
@@ -0,0 +1,101 @@
---
id: cs.network-os.http-tcp
title: 网络基础:从输入 URL 到页面展示、TCP 握手挥手与粘包、HTTP/1.1 / 2 / 3、HTTPS、长连接与 SSE
type: lesson
domain: cs
stack: [network-os]
tags: [TCP, 三次握手, 四次挥手, TIME_WAIT, 粘包, HTTP/2, HTTP/3, HTTPS, TLS, DNS, keep-alive, SSE, WebSocket]
level: basic
prerequisites: []
est_hours: 3
related: [cs.network-os.os-basics, cs.network-os.scenario.connection-troubleshooting, devops.nginx.https-stream-limit]
week: [14, 16]
order: 1
---
# 网络基础:从输入 URL 到页面展示、TCP 握手挥手与粘包、HTTP/1.1 / 2 / 3、HTTPS、长连接与 SSE
> BOSS直聘 2026-10-23 的调研中有岗位提到计算机基础(网络 / 操作系统)。前端出身的你对 HTTP 和浏览器很熟,这里补齐 TCP 和服务端视角。
## 解释说明
### 从输入 URL 到页面展示(经典题,按层回答)
1. **DNS 解析**:浏览器缓存 → 系统缓存 / hosts → 递归解析器 → 根 / 顶级域 / 权威服务器,得到 IP。
2. **建立连接**:TCP 三次握手;HTTPS 再进行 TLS 握手(TLS 1.3 为 1 个往返);HTTP/3 基于 QUIC(UDP),连接和加密握手合并。
3. **发送请求**,经过 CDN / 负载均衡 / 网关到达应用服务器。
4. **服务器处理并响应**。
5. **浏览器渲染**:解析 HTML 构建 DOM、CSS 构建 CSSOM、合成渲染树、布局、绘制、合成;遇到同步脚本会阻塞解析。
### TCP
- **三次握手**:SYN → SYN+ACK → ACK。为什么是三次:双方都要确认“对方能收到我发的”,并同步初始序号;两次无法防止过期的连接请求被误建立。
- **四次挥手**:FIN → ACK → FIN → ACK(因为一方关闭发送后,另一方可能还有数据要发)。
- **TIME_WAIT**:主动关闭方等待 2MSL,确保最后的 ACK 能被重传、旧连接的报文消失。短连接高并发时,主动关闭方(常常是作为客户端的服务)会积累大量 TIME_WAIT —— 解决办法是**连接复用**(连接池、keep-alive),而不是盲目修改内核参数。
- **可靠传输**:序号与确认、超时重传、滑动窗口(流量控制)、拥塞控制(慢启动、拥塞避免)。
- **字节流,没有消息边界**:“粘包 / 拆包”是应用层没有定义边界导致的,要用分隔符或长度前缀解决(示例中实际演示)。
### HTTP 演进
| 版本 | 关键点 |
| --- | --- |
| HTTP/1.1 | 持久连接(keep-alive);一个连接同一时间只能处理一个请求(队头阻塞),浏览器对同域开多个连接 |
| HTTP/2 | 二进制分帧、多路复用(一个连接并发多个流)、头部压缩;TCP 层的丢包仍会阻塞所有流 |
| HTTP/3 | 基于 QUIC(UDP),解决 TCP 层队头阻塞,连接迁移(切换网络不断开) |
### HTTPS
TLS 用非对称加密(或密钥交换)协商出会话密钥,再用对称加密传输数据;证书由 CA 签名,客户端校验证书链和域名,防止中间人。
### 长连接推送:轮询、SSE、WebSocket
| 方式 | 方向 | 适合 |
| --- | --- | --- |
| 轮询 | 客户端拉 | 简单、低频 |
| **SSE** | 服务器 → 客户端,基于普通 HTTP,文本事件,浏览器自动重连 | **大模型流式输出**(OpenAI 等接口都用它) |
| WebSocket | 双向,独立协议 | 聊天、协同编辑、实时语音 |
## 案例
AI 对话接口用 SSE 流式返回:经过 Nginx 时要关闭缓冲;HTTP/1.1 下浏览器对同一域名的并发连接数有限(通常 6 个),用户开多个标签页时 SSE 连接可能占满,HTTP/2 下多路复用没有这个问题。
## 代码示例
[examples/tcp-basics](examples/tcp-basics/)(只用标准库):
```text
$ python framing.py
发送方 send 了 3 次(每次 4 字节),接收方一次 recv 收到 12 字节 → 三条消息粘在一起,边界丢失
长度前缀分帧:每次只读 3 字节,仍然还原出 3 条完整消息:['第0条', '第1条', '第2条']
```
增量解码器(`test_framing.py` 用 100 种随机切分验证):
```python
def feed(self, data: bytes) -> list[dict]:
self.buf += data
out = []
while len(self.buf) >= HEADER.size:
(n,) = HEADER.unpack_from(self.buf)
if n > self.max_frame:
raise ValueError("帧长度超过上限")
if len(self.buf) < HEADER.size + n:
break
out.append(json.loads(bytes(self.buf[HEADER.size:HEADER.size + n])))
del self.buf[:HEADER.size + n]
return out
```
## 易错点
- 认为一次 `send` 对应一次 `recv`。
- 为了解决 TIME_WAIT 乱改内核参数,而不是复用连接。
- 把 HTTP/2 的多路复用和 HTTP/1.1 的管线化混为一谈。
- 不设置超时(连接超时、读超时),上游挂起时线程 / 协程被耗尽。
## 面试常问
- 从输入 URL 到页面展示发生了什么?
- 为什么 TCP 握手是三次、挥手是四次?TIME_WAIT 的作用?
- HTTP/1.1、2、3 的区别?
- SSE 和 WebSocket 的区别?大模型流式输出为什么常用 SSE?
+90
View File
@@ -0,0 +1,90 @@
---
id: cs.network-os.os-basics
title: 操作系统基础:进程线程协程、I/O 模型与多路复用、内存与虚拟内存、文件描述符、死锁
type: lesson
domain: cs
stack: [network-os]
tags: [进程, 线程, 协程, GIL, I/O 多路复用, epoll, 虚拟内存, OOM, 文件描述符, 死锁]
level: basic
prerequisites: [cs.network-os.http-tcp]
est_hours: 3
related: [python.asyncio.index, devops.linux.troubleshooting, cs.network-os.interview]
week: [14, 16]
order: 2
---
# 操作系统基础:进程线程协程、I/O 模型与多路复用、内存与虚拟内存、文件描述符、死锁
## 解释说明
### 进程、线程、协程
| | 进程 | 线程 | 协程 |
| --- | --- | --- | --- |
| 资源 | 独立地址空间 | 共享进程的内存 | 共享线程 |
| 切换 | 内核,开销最大 | 内核,开销中等 | 用户态,开销最小 |
| 通信 | 管道、套接字、共享内存 | 共享变量 + 锁 | 共享变量(单线程内无需锁,但要注意 await 之间的状态变化) |
| 例子 | Gunicorn 多 worker | Java 线程池 | Go goroutine(多线程调度)、Python asyncio(单线程) |
**Python 的 GIL**:同一进程中同一时刻只有一个线程执行 Python 字节码;I/O 密集用线程或 asyncio 都可以,CPU 密集用多进程(Python 3.13 起有可选的无 GIL 自由线程构建,3.14 起官方支持,生态仍在适配,以官方文档为准)。
### I/O 模型
- 阻塞 I/O:一个连接占一个线程。
- **I/O 多路复用**(select / poll / **epoll**):一个线程监视大量文件描述符,内核告诉你哪些就绪。Nginx、Redis、Node.js、asyncio 都基于它。
- 异步 I/O(io_uring 等):提交请求,完成后通知。
### 内存
- **虚拟内存**:每个进程看到独立的地址空间,由页表映射到物理内存;缺页时从磁盘加载。
- 栈(函数调用、局部变量)和堆(动态分配)。
- **OOM**:内存不足时内核选择进程杀掉;容器超过内存上限被 OOMKilled(退出码 137)。
### 文件描述符
Linux 中一切皆文件:文件、套接字、管道都是文件描述符(fd)。每个进程有上限(`ulimit -n`),连接泄漏会导致 “Too many open files”。
### 死锁
四个必要条件:互斥、持有并等待、不可抢占、循环等待。预防:固定加锁顺序、加锁超时、减小锁粒度。数据库中的死锁同理(两个事务以相反顺序更新两行)。
## 案例
Python Agent 服务用 Uvicorn(asyncio):大量请求在等待模型返回(I/O),单个进程就能支撑很多并发连接;但如果在请求处理中同步调用了一个耗时的 CPU 操作(例如解析大 PDF),整个事件循环被阻塞,所有请求都卡住 —— 应该放到进程池或单独的任务队列。
## 代码示例
单线程 + `selectors`(Linux 上为 epoll)同时服务 50 个连接([multiplex_server.py](examples/tcp-basics/multiplex_server.py),运行通过):
```python
sel = selectors.DefaultSelector()
sel.register(srv, selectors.EVENT_READ, data=None)
while not stop.is_set():
for key, _ in sel.select(timeout=0.05):
if key.data is None: # 新连接
conn, _ = srv.accept()
conn.setblocking(False)
sel.register(conn, selectors.EVENT_READ, data="client")
else: # 已有连接可读
data = key.fileobj.recv(1024)
...
```
```text
$ python multiplex_server.py
单线程同时服务 50 个连接,全部回显正确
```
## 易错点
- 在 asyncio 中调用阻塞函数(`time.sleep`、同步 HTTP 客户端、CPU 密集计算)。
- 认为多线程一定能提升 Python 的 CPU 密集任务性能。
- 连接、文件打开后不关闭,fd 耗尽。
- 容器内存上限设得过小,进程被 OOMKilled 却在应用日志中找不到原因。
## 面试常问
- 进程、线程、协程的区别?
- 什么是 I/O 多路复用?epoll 相比 select 好在哪里?
- 什么是死锁?怎么避免?
- Python 的 GIL 是什么?对你的服务有什么影响?
@@ -0,0 +1,92 @@
"""TCP 是字节流:演示“粘包 / 拆包”现象,以及用“长度前缀”协议正确分帧。只用标准库,`python framing.py` 运行。
TCP 只保证字节按顺序可靠到达,不保留“消息边界”:发送方 send 了 3 次,接收方可能 1 次 recv 全部收到,
也可能把一条消息分成多次收到。应用层必须自己定义边界:换行分隔(如 SSE、JSON Lines)或长度前缀(如很多 RPC 协议)。
"""
from __future__ import annotations
import json
import socket
import struct
import threading
HEADER = struct.Struct("!I") # 4 字节无符号整数,网络字节序(大端)
def encode(msg: dict) -> bytes:
body = json.dumps(msg, ensure_ascii=False).encode()
return HEADER.pack(len(body)) + body
class FrameDecoder:
"""增量解码:不管数据被怎样切分送进来,都能还原出完整的消息。"""
def __init__(self, max_frame: int = 1 << 20):
self.buf = bytearray()
self.max_frame = max_frame
def feed(self, data: bytes) -> list[dict]:
self.buf += data
out = []
while len(self.buf) >= HEADER.size:
(n,) = HEADER.unpack_from(self.buf)
if n > self.max_frame:
raise ValueError(f"帧长度 {n} 超过上限,可能是攻击或协议错误")
if len(self.buf) < HEADER.size + n:
break # 数据还不完整,等下一次
body = bytes(self.buf[HEADER.size:HEADER.size + n])
del self.buf[:HEADER.size + n]
out.append(json.loads(body))
return out
def demo_sticky() -> int:
"""连续 send 三次小消息,看接收端一次 recv 拿到几段。"""
srv = socket.create_server(("127.0.0.1", 0))
port = srv.getsockname()[1]
received: list[bytes] = []
def server() -> None:
conn, _ = srv.accept()
with conn:
threading.Event().wait(0.2) # 等发送方把三条都发完
received.append(conn.recv(4096))
t = threading.Thread(target=server)
t.start()
with socket.create_connection(("127.0.0.1", port)) as c:
for i in range(3):
c.sendall(f"msg{i}".encode())
t.join()
srv.close()
return len(received[0])
def demo_framed() -> list[dict]:
srv = socket.create_server(("127.0.0.1", 0))
port = srv.getsockname()[1]
got: list[dict] = []
def server() -> None:
conn, _ = srv.accept()
dec = FrameDecoder()
with conn:
while chunk := conn.recv(3): # 故意每次只读 3 字节,模拟拆包
got.extend(dec.feed(chunk))
t = threading.Thread(target=server)
t.start()
with socket.create_connection(("127.0.0.1", port)) as c:
c.sendall(b"".join(encode({"seq": i, "text": f"第{i}条"}) for i in range(3))) # 一次发出,模拟粘包
t.join()
srv.close()
return got
if __name__ == "__main__":
n = demo_sticky()
note = "三条消息粘在一起,边界丢失" if n > 4 else "这次恰好没有粘包,但不能依赖这一点"
print(f"发送方 send 了 3 次(每次 4 字节),接收方一次 recv 收到 {n} 字节 → {note}")
msgs = demo_framed()
assert [m["seq"] for m in msgs] == [0, 1, 2], msgs
print(f"长度前缀分帧:每次只读 3 字节,仍然还原出 {len(msgs)} 条完整消息:{[m['text'] for m in msgs]}")
@@ -0,0 +1,54 @@
"""I/O 多路复用:单线程用 selectors(Linux 上是 epoll)同时服务多个连接的回显服务器。只用标准库,`python multiplex_server.py` 运行自检。
对比“一个连接一个线程”:多路复用由内核告诉我们哪些连接可读,一个线程就能处理大量空闲连接。
Nginx、Redis、Node.js、Python asyncio 的事件循环都建立在这个机制之上。
"""
from __future__ import annotations
import selectors
import socket
import threading
def serve(srv: socket.socket, stop: threading.Event) -> int:
sel = selectors.DefaultSelector()
srv.setblocking(False)
sel.register(srv, selectors.EVENT_READ, data=None)
max_clients = 0
while not stop.is_set():
for key, _ in sel.select(timeout=0.05):
if key.data is None: # 监听套接字可读 = 有新连接
conn, _ = srv.accept()
conn.setblocking(False)
sel.register(conn, selectors.EVENT_READ, data="client")
max_clients = max(max_clients, len(sel.get_map()) - 1)
else:
conn = key.fileobj
data = conn.recv(1024) # type: ignore[union-attr]
if data:
conn.sendall(data.upper()) # type: ignore[union-attr] # 示例简化:小数据量下 sendall 不会阻塞太久
else: # 对端关闭
sel.unregister(conn)
conn.close() # type: ignore[union-attr]
sel.close()
return max_clients
if __name__ == "__main__":
srv = socket.create_server(("127.0.0.1", 0))
port = srv.getsockname()[1]
stop = threading.Event()
result: list[int] = []
t = threading.Thread(target=lambda: result.append(serve(srv, stop)))
t.start()
clients = [socket.create_connection(("127.0.0.1", port)) for _ in range(50)] # 50 个连接同时在线
for i, c in enumerate(clients):
c.sendall(f"hi{i}".encode())
replies = [c.recv(1024).decode() for c in clients]
for c in clients:
c.close()
stop.set()
t.join()
srv.close()
assert replies == [f"HI{i}" for i in range(50)]
print(f"单线程同时服务 {result[0]} 个连接,全部回显正确")
@@ -0,0 +1,23 @@
import random
import pytest
from framing import FrameDecoder, encode
def test_any_split_restores_messages():
msgs = [{"seq": i, "text": "你好" * i} for i in range(20)]
stream = b"".join(encode(m) for m in msgs)
rng = random.Random(42)
for _ in range(100): # 随机切分 100 种方式
dec, out, i = FrameDecoder(), [], 0
while i < len(stream):
j = i + rng.randint(1, 17)
out += dec.feed(stream[i:j])
i = j
assert out == msgs
def test_rejects_oversized_frame():
with pytest.raises(ValueError):
FrameDecoder(max_frame=10).feed(encode({"text": "x" * 100}))
+25 -3
View File
@@ -4,12 +4,34 @@ title: 网络与操作系统基础
type: index
domain: cs
stack: [network-os]
tags: []
tags: [TCP, HTTP, HTTPS, 进程线程, I/O 多路复用]
week: [14, 16]
---
# 网络与操作系统基础
HTTP/HTTPS、TCP/IP、DNS、进程线程、内存、IO 模型。
HTTP/HTTPS、TCP、DNS、SSE 与 WebSocket;进程线程协程、I/O 多路复用、内存、文件描述符。BOSS直聘 2026-10-23 的调研中有岗位提到计算机基础。
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
## 学习路线
| 顺序 | 课程 | 级别 | 预计 |
| --- | --- | --- | --- |
| 1 | [网络基础:从输入 URL 到页面展示、TCP 握手挥手与粘包、HTTP/1.1 / 2 / 3、HTTPS、长连接与 SSE](01-http-tcp.md) | 基础 | 3 小时 |
| 2 | [操作系统基础:进程线程协程、I/O 模型与多路复用、内存与虚拟内存、文件描述符、死锁](02-os-basics.md) | 基础 | 3 小时 |
## 企业场景
- [线上连接问题排查:大量 TIME_WAIT、连接池耗尽、fd 用尽和事件循环阻塞](scenarios/connection-troubleshooting.md)
## 面试题
- [网络与操作系统面试题](interview.md)
## 示例代码
- [examples/tcp-basics](examples/tcp-basics/):粘包现象与长度前缀分帧(随机切分测试)、单线程 selectors 多路复用回显服务器(只用标准库)
## 在 16 周计划中
- [第 14 周:后端扩展与部署](../../../plan/week14-backend-extend-deploy.md)
- [第 16 周:面试冲刺](../../../plan/week16-interview.md)
+67
View File
@@ -0,0 +1,67 @@
---
id: cs.network-os.interview
title: 网络与操作系统面试题
type: interview
domain: cs
stack: [network-os]
tags: [TCP, HTTP, HTTPS, 进程线程, I/O 多路复用, 面试]
level: basic
related: [cs.network-os.http-tcp, cs.network-os.os-basics]
week: [14, 16]
---
# 网络与操作系统面试题
## 基础
### 【基础】从输入 URL 到页面展示,发生了什么?
**参考答案**:DNS 解析 → TCP 握手(HTTPS 再 TLS 握手)→ 发送 HTTP 请求,经 CDN / 负载均衡 / 网关到应用 → 服务器处理返回 → 浏览器解析 HTML / CSS 构建 DOM 和 CSSOM、布局、绘制、合成,执行脚本。
**追问**:哪些环节可以优化?→ DNS 预解析、连接复用、HTTP/2、CDN、压缩、缓存、关键资源预加载、减少阻塞脚本。
### 【基础】为什么 TCP 握手三次、挥手四次?
**参考答案**:三次握手让双方都确认对方的收发能力并同步初始序号,同时防止过期的连接请求建立连接;挥手时一方发送 FIN 只表示自己不再发送,另一方可能还有数据要发,所以 ACK 和 FIN 分开发送。
**追问**:TIME_WAIT 有什么作用?→ 确保最后一个 ACK 丢失时能重传,并让旧连接的延迟报文在网络中消失,避免干扰新连接。
### 【基础】进程、线程、协程的区别?
**参考答案**:进程是资源分配单位,独立地址空间;线程是调度单位,共享进程资源,由内核切换;协程在用户态调度,切换开销最小,适合大量 I/O 等待。
**追问**:Go 的 goroutine 和 Python 的协程有什么不同?→ goroutine 由 Go 运行时调度到多个系统线程上,可以利用多核,遇到阻塞自动切换;Python asyncio 协程运行在单线程事件循环中,需要显式 `await`,阻塞调用会卡住整个循环。
## 进阶
### 【进阶】HTTP/1.1、HTTP/2、HTTP/3 的区别?
**参考答案**:1.1 有持久连接,但同一连接上请求串行(队头阻塞);2 使用二进制分帧和多路复用、头部压缩,但 TCP 丢包仍会阻塞全部流;3 基于 QUIC(UDP),解决传输层队头阻塞,握手更快,支持连接迁移。
**追问**:HTTP/2 下还需要合并资源、域名分片吗?→ 一般不需要,多路复用已经解决并发问题,域名分片反而增加连接开销。
### 【进阶】什么是 I/O 多路复用?epoll 为什么比 select 高效?
**参考答案**:一个线程监视多个 fd,就绪时再处理。select 每次调用都要把全部 fd 拷贝到内核并线性扫描,且有数量上限;epoll 在内核中维护关注列表,就绪的 fd 通过回调放入就绪队列,只返回就绪的,适合大量连接。
**追问**:水平触发和边缘触发?→ 水平触发:只要还可读就一直通知;边缘触发:状态变化时只通知一次,必须一次读完,否则可能丢失通知。
### 【进阶】什么是粘包?怎么解决?
**参考答案**:TCP 是字节流,没有消息边界,多条消息可能合并或被拆分到达。应用层定义边界:固定长度、分隔符(换行,如 SSE、JSON Lines)、长度前缀;接收方用缓冲区增量解析。
**追问**:长度前缀协议要注意什么安全问题?→ 限制最大帧长度,防止恶意的超大长度值导致内存耗尽。
## 场景题
### 【场景题】服务调用下游时出现大量 TIME_WAIT 和 “Cannot assign requested address”,怎么处理?
**参考答案**:这是作为主动关闭方的短连接过多、本地端口耗尽。根本办法是复用连接(共享 HTTP 客户端、连接池、keep-alive);同时检查超时设置和并发上限;内核参数调整只作为辅助。详见[连接问题排查](scenarios/connection-troubleshooting.md)。
**追问**:怎么确认修复有效?→ 压测对比 TIME_WAIT 数量、建连次数和 P99 延迟。
### 【场景题】异步 Python 服务中所有请求(包括健康检查)同时变慢,可能是什么原因?
**参考答案**:事件循环被阻塞:在协程中执行了同步 I/O 或 CPU 密集操作。排查:开启 asyncio 调试模式查看慢回调、采样分析器定位;修复:使用异步客户端、把 CPU 任务放到进程池或任务队列。
**追问**:为什么健康检查也慢?→ 它和其他请求运行在同一个事件循环中,循环被占用时所有协程都得不到调度。
@@ -0,0 +1,84 @@
---
id: cs.network-os.scenario.connection-troubleshooting
title: 线上连接问题排查:大量 TIME_WAIT、连接池耗尽、fd 用尽和事件循环阻塞
type: scenario
domain: cs
stack: [network-os, linux, fastapi]
tags: [TIME_WAIT, 连接池, 文件描述符, 事件循环阻塞, 超时, 排查]
level: intermediate
prerequisites: [cs.network-os.http-tcp, cs.network-os.os-basics]
est_hours: 2
related: [cs.network-os.interview, devops.linux.scenario.incident-troubleshooting]
week: [14, 16]
---
# 线上连接问题排查:大量 TIME_WAIT、连接池耗尽、fd 用尽和事件循环阻塞
## 业务背景与问题
AI Agent 服务(FastAPI)高峰期偶发大量超时,日志中出现:
- 调用模型网关报 “Cannot assign requested address”;
- 偶尔出现 “Too many open files”;
- 所有请求的延迟同时变高,包括健康检查。
## 约束
- 不能停机排查。
- 运维只给了容器内的只读排查权限。
## 方案设计
1. **看连接状态**:`ss -s`、`ss -tan state time-wait | wc -l` 发现几万个 TIME_WAIT,目标都是模型网关 → 代码中每次请求都新建 `httpx.AsyncClient`,用完就关闭,没有复用连接。**修复**:应用级共享一个客户端(连接池),设置池大小和 keep-alive。
2. **看 fd**:`ls /proc/<pid>/fd | wc -l` 与 `ulimit -n` 对比 → 文件上传后临时文件没有关闭。**修复**:使用 `with` 管理资源;在监控中加入 fd 数量。
3. **看事件循环**:所有请求同时变慢,说明事件循环被阻塞 → 用 asyncio 调试模式 / 采样分析发现同步的 PDF 解析。**修复**:移到进程池(`run_in_executor`)或任务队列。
4. **超时与隔离**:所有外部调用设置连接超时和读超时;对模型网关设置并发上限(信号量),防止一个慢依赖耗尽所有资源。
5. **验证**:压测对比修复前后的 TIME_WAIT 数量、fd 数量、P99 延迟。
## 关键代码
```python
from contextlib import asynccontextmanager
import httpx
from fastapi import FastAPI
@asynccontextmanager
async def lifespan(app: FastAPI):
# 整个应用共享一个客户端:复用 TCP / TLS 连接
app.state.llm = httpx.AsyncClient(
base_url=LLM_GATEWAY,
timeout=httpx.Timeout(connect=3, read=60, write=10, pool=5),
limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
)
yield
await app.state.llm.aclose()
app = FastAPI(lifespan=lifespan)
@app.post("/parse")
async def parse(file: UploadFile):
data = await file.read()
loop = asyncio.get_running_loop()
return await loop.run_in_executor(process_pool, parse_pdf, data) # CPU 密集任务不阻塞事件循环
```
相关原理:[网络基础](../01-http-tcp.md)、[操作系统基础](../02-os-basics.md);Linux 排查命令见 [Linux 线上排查](../../../devops/linux/scenarios/incident-troubleshooting.md)。
## 取舍
| 选择 | 优点 | 缺点 |
| --- | --- | --- |
| **复用连接(本方案)** | 根治 TIME_WAIT,同时降低延迟(省去握手) | 要管理客户端生命周期 |
| 调整内核参数(端口范围、TIME_WAIT 复用) | 立刻见效 | 治标不治本,有副作用,容器内往往无权限 |
| 增加实例 | 简单 | 掩盖问题,成本上升 |
## 易错点
- 看到 TIME_WAIT 就认为是服务器的问题——它出现在主动关闭的一方。
- 共享的客户端没有设置池上限,慢依赖拖垮整个服务。
- 只设置了总超时,没有区分连接超时和读超时(流式响应的读超时要考虑 token 间隔)。
## 面试怎么讲
> “Agent 服务高峰期出现‘Cannot assign requested address’,用 ss 看到几万个 TIME_WAIT 指向模型网关,原因是每次请求新建 HTTP 客户端。改成应用级共享客户端并配置连接池和分阶段超时后,TIME_WAIT 基本消失,延迟也下降了。另外发现同步 PDF 解析阻塞事件循环,导致所有请求同时变慢,移到进程池解决。修复后用压测对比了连接数、fd 数和 P99。”