计算机网络八股与工程(秋招速通版)¶
核心概念¶
(a) 🗂️ 计算机网络全景:分层模型是骨架,TCP/HTTP 是血肉¶
网络八股的一条主线是「分层」:从 OSI 七层 / TCP-IP 四层模型出发,向上是 TCP 的连接管理与可靠传输,再向上是 HTTP/HTTPS 与 DNS,最后用「输入 URL 到页面显示」把整条链路串成压轴综合题。下图就是整篇的导航地图。
(该图在 GitHub/VSCode + mermaid 插件中可渲染)
flowchart TB
Model["🧱 分层模型<br/>OSI 七层 / TCP-IP 四层"]
Model --> Tcp["🤝 TCP 连接管理<br/>三次握手 + 四次挥手"]
Tcp --> Rel["📡 可靠传输<br/>重传 + 滑动窗口"]
Rel --> Flow["🚦 流量控制 vs 拥塞控制"]
Model --> Udp["⚖️ TCP vs UDP(含 QUIC)"]
Model --> Http["🌐 HTTP 报文 / 状态码 / 演进"]
Http --> Tls["🔐 HTTPS 与 TLS 证书链"]
Model --> Dns["📇 DNS 与 CDN"]
Http --> Journey["🏁 输入 URL 到页面显示"]
Dns --> Journey
Tls --> Journey
- 🧱 分层模型:OSI 七层(物理→应用)是理论参考,TCP/IP 四层(网络接口 / 网际 / 传输 / 应用)才是事实标准。要会讲数据封装与解封装:发送时从上往下逐层加头部,接收时从下往上逐层剥。
- 🤝 TCP 连接管理:三次握手(SYN → SYN+ACK → ACK)解决「双方都能收发 + 防止历史报文错连」,为什么不能两次要会论证;四次挥手(FIN → ACK → FIN → ACK)源于 TCP 半关闭,TIME_WAIT 等 2MSL 的原因与调优也是必背。
- 📡 可靠传输:TCP 靠序号 + 确认 + 超时重传 + 快速重传 + 滑动窗口保证可靠与效率。RTO 按 RFC 6298 计算、重传指数退避(1s → 2s → 4s…),这些公式与 Python 模拟代码都要能讲。
- 🚦 流量控制 vs 拥塞控制:流量控制是「接收方怕你太快」,靠调整窗口大小;拥塞控制是「网络怕你太快」,靠慢启动、拥塞避免、快重传、快恢复四条线调节 cwnd。两者管的对象不同,是最爱考的一对辨析。
- ⚖️ TCP vs UDP:TCP 可靠有序但慢,UDP 无连接、低延迟;视频通话、DNS、游戏走 UDP。QUIC 基于 UDP 重造可靠传输与多路复用,是为了在用户态快速迭代并避开 TCP 的队头阻塞。
- 🌐 HTTP 报文 / 状态码 / 演进:请求行 / 头部 / 空行 / 正文的结构、GET vs POST、状态码 1xx~5xx 分类要熟。HTTP/1.0 → 1.1(长连接)→ 2(二进制分帧、HPACK 头部压缩、多路复用)→ 3(QUIC)的演进与队头阻塞问题是高频考点。
- 🔐 HTTPS 与 TLS:对称加密快、非对称加密安全,TLS 用「混合加密」结合两者。握手要能讲出协商密钥与证书验证的完整流程,CA 证书链为什么能防中间人攻击也要说清。
- 📇 DNS 与 CDN:DNS 走递归 + 迭代查询,从浏览器缓存 → 本地 DNS → 根 / 顶级 / 权威服务器逐级解析;CDN 通过 DNS 调度把用户带到最近的边缘节点,两者关系是 URL 综合题的必备环节。
- 🏁 输入 URL 到页面显示:压轴综合题:DNS 解析 → TCP 三次握手 → TLS 握手 → HTTP 请求 → 服务器响应 → 浏览器渲染,每层还有缓存(DNS 缓存 / CDN / 浏览器缓存)。能按时间线完整复述,基本就覆盖了全部网络考点。
面向算法 / 后端秋招的计算机网络高频考点整理。每个主题均包含:定义与原理讲解、 公式或伪代码、可直接运行的 Python 3 示例、对比表格、面试追问与标准回答、 易错点 / 面试点评。建议先通读建立体系,再按每节末尾的「追问」逐条自测。
本文目录 1. OSI 七层与 TCP/IP 四层模型对比 2. TCP 三次握手(状态迁移 / 为什么是 3 次 / SYN 泛洪) 3. TCP 四次挥手(半关闭 / TIME_WAIT 与 2MSL) 4. TCP 可靠传输机制(ACK / RTO / 快速重传 / 滑动窗口) 5. 流量控制 vs 拥塞控制(四条线 + cwnd 示意图) 6. TCP vs UDP(含 QUIC 为什么基于 UDP) 7. HTTP 报文结构、方法(GET/POST)与状态码 8. HTTP 1.0 / 1.1 / 2 / 3 演进(队头阻塞 / HPACK / QUIC) 9. HTTPS 与 TLS(握手流程 / 证书链 / 混合加密) 10. DNS 解析完整流程与 CDN 11. 经典综合题:输入 URL 到页面显示的完整过程
1. OSI 七层与 TCP/IP 四层模型¶
💡 定义(小白版):OSI 七层模型把「两台设备怎么通信」这件大事拆成 7 个步骤(层),每一层只负责自己那摊活,只和上下邻居打交道。 🏷️ 类比:就像寄快递:写地址(应用层)→ 装箱打包(表示层)→ 约好取件时间(会话层)→ 选快递方式(传输层)→ 规划路线(网络层)→ 分拣装车(数据链路层)→ 开车上路(物理层)。任何一层出问题都能单独定位、单独修。
1.1 OSI 七层模型(参考模型,重在分层思想)¶
| 层 | 名称 | 核心职责 | 典型协议 / 设备 |
|---|---|---|---|
| 7 | 应用层 | 面向用户的应用协议,提供网络服务接口 | HTTP / HTTPS / DNS / FTP / SMTP |
| 6 | 表示层 | 数据格式转换、加密、压缩(编码与解码) | ASCII / JPEG / SSL 的一部分语义 |
| 5 | 会话层 | 建立、管理、终止会话(连接同步) | NetBIOS、RPC |
| 4 | 传输层 | 端到端可靠或尽力传输、端口寻址、分片重组 | TCP / UDP |
| 3 | 网络层 | 逻辑寻址(IP)、路由选择、分组转发 | IP / ICMP / ARP、路由器 |
| 2 | 数据链路层 | 物理寻址(MAC)、帧封装、差错检测 | Ethernet / PPP、交换机 |
| 1 | 物理层 | 比特流传输、电气/机械特性 | 双绞线 / 光纤、集线器 |
记忆口诀(自下而上):物 链 网 传 会 表 应;自上而下:应 表 会 传 网 链 物。
1.2 TCP/IP 四层模型(事实标准)¶
- 应用层:对应 OSI 的应用层 + 表示层 + 会话层(合并),如 HTTP、DNS。
- 传输层:TCP / UDP,负责端口到端口的通信。
- 网络层(网际层):IP、ICMP、路由,负责主机到主机的寻址与转发。
- 网络接口层(链路层):对应 OSI 的数据链路层 + 物理层,负责在同一物理链路上的帧传输。
1.3 两层模型对比表¶
| 对比维度 | OSI 七层 | TCP/IP 四层 |
|---|---|---|
| 分层数量 | 7 层 | 4 层 |
| 性质 | 理论参考模型,先有模型后有协议 | 实际工程模型,先有协议后归纳 |
| 表示层 / 会话层 | 独立成层 | 合并进应用层 |
| 数据链路层 / 物理层 | 独立成层 | 合并为网络接口层 |
| 传输层可靠性 | 概念上提供,未强调 | TCP 提供可靠、UDP 提供尽力而为 |
| 主要用途 | 教学、标准化讨论 | 实际网络(Internet)实现 |
1.4 数据封装与解封装(伪代码)¶
发送端:应用数据 → 应用层 → 传输层加 TCP/UDP 头 → 网络层加 IP 头
→ 链路层加 MAC 头与 FCS 尾部 → 物理层转比特流
接收端:反向逐层剥头(解封装),每层只处理本层头部
1.5 面试追问¶
🧭 答法提示:被追问分层的题,先答「这一层管什么、管不到什么」,再举一个层间配合的例子(如跨网段必须路由器换 MAC 头)。别从 OSI 的历史背景开始铺垫,先给结论。
追问 1:为什么实际网络不用 OSI 七层,而用 TCP/IP 四层? 标准回答: OSI 是理想化参考模型,分层过细(表示层、会话层在实践中边界模糊),且是先定模型再定协议,落地困难;TCP/IP 是先有实现后归纳的模型,贴近真实协议栈,工程可实施性强。
追问 2:TCP 层收到重复或乱序数据怎么办? 标准回答: 传输层用序号 + 确认号 + 接收窗口做排序、去重、流量控制;网络层只保证尽力转发,不保证顺序。
追问 3:为什么说「数据链路层只在本链路上传输」? 标准回答: MAC 寻址只对同一广播域有效,跨网段必须由网络层 IP 寻址 + 路由器转发,逐跳更换 MAC 地址。
⚠️ 易错点:ARP 属于网络层还是链路层?ARP 用于 IP→MAC 映射,常归入网络层(或说横跨 2/3 层);不要把 ICMP 归为传输层,它是网络层的辅助协议。
2. TCP 三次握手¶
💡 定义(小白版):TCP(传输控制协议)是一种「先电话连线、再传文件」的协议:发数据前双方先确认「我在、你能听到我、我也能听到你」,传输中丢失的包会自动重发,保证对方收到的内容不缺、不乱、不重。 🏷️ 类比:TCP 就像打电话:拨号(SYN)→ 对方接起「喂?」(SYN+ACK)→ 你回「是我」(ACK),确认通了才开讲;中途谁说「没听清」就重说一遍(重传)。
2.1 定义与过程¶
三次握手(Three-Way Handshake) 是 TCP 建立连接时双方交换三个报文段以同步初始序号(ISN)并确认双方收发能力的过程。
客户端 服务端
|----- ① SYN(seq=x) ---------------->| SYN_SENT → LISTEN 收到
| | LISTEN → SYN_RCVD
|<----- ② SYN+ACK(seq=y, ack=x+1) ---| SYN_RCVD → ESTABLISHED(服务端)
|----- ③ ACK(seq=x+1, ack=y+1) ----->| SYN_SENT → ESTABLISHED(客户端)
- 第 1 次:客户端发 SYN=1, seq=x,进入 SYN_SENT。
- 第 2 次:服务端回 SYN=1, ACK=1, seq=y, ack=x+1,进入 SYN_RCVD。
- 第 3 次:客户端发 ACK=1, seq=x+1, ack=y+1,双方进入 ESTABLISHED。
2.2 状态迁移表¶
| 端 | 状态序列 |
|---|---|
| 客户端 | CLOSED → SYN_SENT → ESTABLISHED |
| 服务端 | LISTEN → SYN_RCVD → ESTABLISHED |
2.3 为什么必须是 3 次(两个核心理由)¶
- 防止历史重复连接:若客户端发出的旧 SYN 迟到,服务端若只回一次 ACK 就建立连接,会被过期报文误导;三次握手让客户端收到 SYN+ACK 后能根据序号判断是否为历史连接,若是则发 RST 终止,避免服务端建立无效连接。
- 确认双方收发能力都正常:第一次证明「客户端能发、服务端能收」;第二次证明「服务端能发、客户端能收」;第三次是客户端明确告知服务端「我收到你的 SYN+ACK」,从而让服务端确认「客户端能收」。两次握手无法让服务端确认客户端已就绪。
补充数学视角:握手次数最少为 3,是因为「确认对方收到了自己的确认」需要一轮额外往返;4 次则多一次无用往返,故 3 次是最优。
2.4 SYN 泛洪攻击(SYN Flood)¶
- 原理:攻击者伪造大量源 IP 发送 SYN,服务端回复 SYN+ACK 后进入 SYN_RCVD 并分配内核资源(半连接队列),但不完成第三次握手,很快占满半连接队列,导致正常客户端无法建立连接。
- 缓解手段:
- SYN Cookie:不分配队列资源,用
(源IP、源端口、时间、密钥)哈希生成序号返回,收到 ACK 时再验证合法性; - 缩短 SYN 超时时间、限制半连接队列上限、
tcp_syncookies=1; - 网络层:防火墙限速 / 清洗。
2.5 Python 3 可运行示例(模拟握手与历史报文拒绝)¶
"""模拟 TCP 三次握手,并演示「历史迟到 SYN 会被拒绝」的场景。
纯标准库,可直接运行。"""
from dataclasses import dataclass
@dataclass
class Pkt:
flags: str # 例如 'SYN', 'SYN+ACK', 'ACK', 'RST'
seq: int
ack: int
stale: bool = False # 是否为迟到的历史报文
def handshake(client_isn=100, server_isn=300, with_stale_syn=False):
print("== 正常三次握手 ==")
c_seq, s_seq = client_isn, server_isn
# ① 客户端发 SYN
c_seq += 1
p1 = Pkt('SYN', seq=c_seq, ack=0)
print(f"客户端 -> 服务端: {p1}")
# ② 服务端回 SYN+ACK
s_seq += 1
p2 = Pkt('SYN+ACK', seq=s_seq, ack=c_seq + 1)
print(f"服务端 -> 客户端: {p2}")
# ③ 客户端回 ACK
c_seq += 1
p3 = Pkt('ACK', seq=c_seq, ack=s_seq + 1)
print(f"客户端 -> 服务端: {p3}")
print("双方进入 ESTABLISHED。\n")
if with_stale_syn:
print("== 历史迟到 SYN 场景 ==")
stale = Pkt('SYN', seq=50, ack=0, stale=True) # 旧连接残留的 SYN
print(f"客户端 -> 服务端: {stale} (迟到的旧 SYN)")
# 服务端按新 SYN 处理会回 SYN+ACK,ack=51
s_seq += 1
resp = Pkt('SYN+ACK', seq=s_seq, ack=stale.seq + 1)
print(f"服务端 -> 客户端: {resp}")
# 客户端发现 seq=50 不是自己当前期望的序号 → 发 RST 拒绝
print(f"客户端 -> 服务端: RST (客户端判断这是历史连接,直接终止)")
print("结论:三次握手让客户端有能力拒绝历史连接。")
if __name__ == '__main__':
handshake(with_stale_syn=True)
2.6 面试追问¶
🧭 答法提示:答握手题先画三行报文图(SYN / SYN+ACK / ACK)再讲「为什么不是 2 次或 4 次」;提到 SYN Flood 时主动补一句「SYN Cookie 不占半连接队列资源」,能明显加分。
追问 1:两次握手为什么不行? 标准回答: 两次握手只能确认服务端「能收能发」,无法确认客户端是否收到 SYN+ACK;且无法处理历史重复 SYN——服务端收到重发的旧 SYN 就会直接建立连接,浪费资源并可能造成数据错乱。
追问 2:三次握手中可以携带数据吗? 标准回答: 前两次(SYN、SYN+ACK)不能携带应用数据(SYN 报文本身不携带数据,序号消耗 1);第三次 ACK 可以携带数据(此时客户端已确认双方就绪)。
追问 3:什么是 SYN Cookie,如何工作?
标准回答: 服务端收到 SYN 时不进半连接队列,而是把 (IP、端口、时间戳、密钥) 做哈希生成一个特殊序号当作 SYN+ACK 的 seq 返回;收到客户端 ACK 时校验 ack-1 是否等于该哈希,验证通过才分配连接。从而在 SYN 泛洪下不耗尽资源。
⚠️ 易错点:SYN Flood 消耗的是半连接队列而非全连接队列;第三次握手丢失时客户端会重传 ACK,服务端 SYN_RCVD 超时后重传 SYN+ACK(Linux 默认重传 5 次)。
3. TCP 四次挥手¶
💡 定义(小白版):四次挥手是 TCP「挂电话」的四步流程:因为通话是双向的(全双工),每一边都要单独说一次「我要挂了」,所以需要 4 个报文才关得干净。 🏷️ 类比:像宿舍关灯道别:A 说「我先不说了,你还有要说的吗?」(FIN)→ B 回「好的,我听到了」(ACK)→ B 把话说完再说「我说完了,挂吧」(FIN)→ A 回「收到,挂」(ACK)。B 没说完话前不能一起回,所以必须 4 次。
3.1 过程¶
四次挥手(Four-Way Handshake) 用于关闭 TCP 连接,核心在于 TCP 是全双工,每个方向需要独立关闭,因此需要 4 个报文。
主动关闭方 A 被动关闭方 B
|----- ① FIN(seq=u) ---------------->| ESTABLISHED → FIN_WAIT_1
|<----- ② ACK(ack=u+1) --------------| B → CLOSE_WAIT,A → FIN_WAIT_2
| (B 继续发送剩余数据) |
|<----- ③ FIN(seq=w) ----------------| B 发完数据后 → LAST_ACK
|----- ④ ACK(ack=w+1) -------------->| B → CLOSED;A → TIME_WAIT(2MSL)
- ① A 发 FIN,进入 FIN_WAIT_1(A 不再发数据,但仍可收);
- ② B 回 ACK,进入 CLOSE_WAIT(B 还可以继续发数据),A 进入 FIN_WAIT_2;
- ③ B 数据发完后发 FIN,进入 LAST_ACK;
- ④ A 回 ACK 后进入 TIME_WAIT(持续 2MSL),B 收到后进入 CLOSED。
3.2 为什么是 4 次(半关闭)¶
因为 ② 和 ③ 不能合并:B 收到 FIN 后未必立刻没有数据要发,ACK 只是确认收到 FIN,而 FIN 要等 B 把剩余数据发完才能发出,所以 ACK 与 FIN 天然分离 → 4 次挥手是全双工关闭的最少次数。若 B 恰好无数据且支持延迟 ACK 合并,个别实现可能把 ②③ 合并成 3 个报文,但语义上仍是 4 个阶段。
3.3 TIME_WAIT 的作用与 2MSL 的原因¶
- 作用 1(可靠终止):保证最后的 ACK 丢失时能重传(若 B 的 FIN 重传,A 可再回 ACK),否则 B 会一直停在 LAST_ACK;
- 作用 2(防旧报文串扰):保证本次连接的所有报文在网络中彻底消失(MSL 为报文最大生存时间,双向最坏 2MSL),避免与后续新连接(相同四元组)的报文混淆。
3.4 大量 TIME_WAIT 的后果与调优¶
| 后果 | 说明 |
|---|---|
| 端口耗尽 | 客户端短连接场景下 TIME_WAIT 占用本地端口(默认约 2~4 分钟),高并发 QPS 下可能 Cannot assign requested address |
| 内存/表项开销 | 每个 TIME_WAIT 保留内核 sock 结构,百万级连接占用可观内存 |
| 新连接被延迟 | 相同四元组的新连接须等 TIME_WAIT 结束(除非开启 reuse) |
调优手段:
- 服务端开启 SO_REUSEADDR(允许 TIME_WAIT 端口被复用监听);
- Linux 开启 net.ipv4.tcp_tw_reuse=1(仅对出站连接,且要求时间戳选项开启,安全复用 TIME_WAIT 端口);
- 调小 tcp_fin_timeout / 缩短 MSL(需谨慎,破坏防串扰保证);
- 业务层:改用长连接(连接池)、HTTP/2 多路复用减少建连频率;
- 不建议在生产盲目开 tcp_tw_recycle(已被移除,且依赖时间戳,NAT 场景会误杀报文)。
3.5 Python 3 可运行示例(挥手状态机模拟)¶
"""模拟四次挥手的报文与状态迁移(标准库,可直接运行)。"""
from dataclasses import dataclass
@dataclass
class Pkt:
flags: str
seq: int
ack: int
def four_way_close(a_isn=500, b_isn=800, fin_lost=False):
a, b = a_isn, b_isn
print("== 四次挥手 ==")
# ① A 发 FIN
a += 1
print(f"A -> B: FIN(seq={a}) A: ESTABLISHED -> FIN_WAIT_1")
# ② B 回 ACK
b += 1
print(f"B -> A: ACK(ack={a + 1}) B -> CLOSE_WAIT, A -> FIN_WAIT_2")
print("(B 继续发送剩余数据……)")
# ③ B 发 FIN
b += 1
print(f"B -> A: FIN(seq={b}) B -> LAST_ACK")
# ④ A 回 ACK
a += 1
if fin_lost: # 演示 B 的 FIN 丢失场景:B 重传 FIN
print("(B 的 FIN 丢失,B 超时重传 FIN)")
b += 1
print(f"B -> A: FIN(seq={b}) (重传)")
print(f"A -> B: ACK(ack={b + 1}) A -> TIME_WAIT(2MSL) -> CLOSED")
print("B 收到 ACK -> CLOSED")
if __name__ == '__main__':
four_way_close(fin_lost=True)
3.6 面试追问¶
🧭 答法提示:挥手题先分清「主动方 / 被动方」再做状态迁移;没时间展开就说清「ACK 与 FIN 为什么必须分开发(半关闭)」。TIME_WAIT 题先答「在主动关闭方、持续 2MSL」,再讲两个作用:保证最后 ACK 可重传、防旧报文串扰。
追问 1:为什么主动关闭方要等 2MSL 而不是立刻关闭? 标准回答: ① 保证最后的 ACK 若丢失,能响应对方重传的 FIN;② 让本连接在网络中的报文(最大生命周期 MSL)全部消散,防止四元组相同的后续新连接收到旧报文。2MSL = 一来一回的最大时间。
追问 2:TIME_WAIT 过多时优先调什么?
标准回答: 优先从业务架构入手:客户端用连接池/长连接减少建连;服务端监听套接字开 SO_REUSEADDR;谨慎开启 tcp_tw_reuse(仅出站)。不要盲目调小 2MSL。
追问 3:如果服务端收到 FIN 后一直不回复会怎样? 标准回答: 客户端停留在 FIN_WAIT_1,超时后重传 FIN;若持续无响应最终进入 CLOSED。被动方进入 CLOSE_WAIT 后若应用不 close,会泄漏 CLOSE_WAIT 连接(常见于应用层忘记关闭 socket)。
⚠️ 易错点:TIME_WAIT 存在于主动关闭方;面试常考「大量 TIME_WAIT 出现在哪一端」——通常是短连接客户端(如压测工具、网关)。
4. TCP 可靠传输机制¶
💡 定义(小白版):滑动窗口规定「允许同时在路上的数据最多有多少」——发方按窗口大小连续发一堆包,收方确认后窗口前移、继续发下一批,既保证不把对方冲垮,又不傻等一个个来回。 🏷️ 类比:像机场安检传送带:窗口就是「同时最多放几件行李在传送带上」;行李过了安检(收到 ACK),就能再往前放新行李(窗口滑动)。窗口越大越高效,但带子太满也会乱。
4.1 机制总览¶
| 机制 | 作用 | 关键点 |
|---|---|---|
| 确认应答 ACK | 接收方告知发送方已收到哪些字节 | 确认号 = 期望收到的下一个字节序号 |
| 超时重传 | 发送方超时未收到 ACK 则重发 | 重传计时器 RTO 动态计算 |
| 快速重传 | 收到 3 个冗余 ACK 立即重传 | 不等超时,减少等待 |
| 累计确认 | ACK n 表示 1..n-1 全部收到 | 丢失后续报文只需重传从缺口开始 |
| 滑动窗口 | 限制在途数据量,实现流量控制 | 发送窗口 = min(拥塞窗口, 接收窗口) |
4.2 超时重传与 RTO 计算(RFC 6298 公式)¶
SRTT = (1 - α) × SRTT + α × RTT # α = 1/8,平滑往返时间
RTTVAR = (1 - β) × RTTVAR + β × |RTT - SRTT| # β = 1/4,抖动方差
RTO = SRTT + max(G, 4 × RTTVAR) # G 为时钟粒度(如 1ms)
# 初始 RTO = 1s,重传后采用指数退避:RTO = RTO × 2(上限 60s)
4.3 快速重传(Fast Retransmit)¶
- 接收方收到乱序报文时,每收到一个乱序段就回复对最近有序字节的 ACK(冗余 ACK);
- 发送方收到 3 个相同的冗余 ACK(即第 4 次重复)时,不等超时立即重传缺失报文;
- 优点:更快恢复;代价:无法区分「丢包」还是「乱序」(乱序也会触发冗余 ACK),后续有 SACK(选择性确认) 精准告知缺口。
4.4 滑动窗口(发送 / 接收窗口)¶
发送窗口维护三指针:
窗口内:
| 已发送已确认 | 已发送未确认 | 可发送未发送 | 不可发送 |
|<- 窗口左沿前进 ->|<---- 发送窗口 W ---->|
可用窗口 = 发送窗口 - 已发送未确认
- 发送窗口 = min(拥塞窗口 cwnd, 接收窗口 rwnd);
- 接收窗口 rwnd 由接收方在 TCP 头
window字段通告,实现流量控制(防止发送方淹没接收方缓冲区)。
4.5 Python 3 可运行示例(滑动窗口 + 快速重传模拟)¶
"""模拟滑动窗口发送与快速重传(标准库,可直接运行)。"""
import random
def send_with_window(data, win_size=4, drop_idx=None):
"""data: 待发送字节序号列表;win_size: 发送窗口;drop_idx: 模拟丢包的序号。"""
acked = set() # 已确认
sent_but_unacked = {} # 序号 -> 是否收到冗余ACK计数
base, nxt = 0, 0 # 窗口基址 / 下一个待发序号
dup_ack = {}
while base < len(data):
# 填充窗口:可发送 = base + win_size 之前且未发送
while nxt < min(base + win_size, len(data)):
seq = data[nxt]
if seq == drop_idx:
print(f"发送 seq={seq} (该包在网络上丢失)")
else:
print(f"发送 seq={seq}")
sent_but_unacked[seq] = 1
nxt += 1
# 模拟接收方 ACK(丢包的序号不确认)
for seq in list(sent_but_unacked):
if seq == drop_idx:
dup_ack[seq] = dup_ack.get(seq, 0) + 1
if dup_ack[seq] == 3:
print(f"!! 收到 3 个冗余 ACK,快速重传 seq={seq}(不等超时)")
sent_but_unacked[seq] = 1
dup_ack[seq] = 0
else:
acked.add(seq)
sent_but_unacked.pop(seq, None)
dup_ack.pop(seq, None)
# 窗口左沿前进到第一个未确认位置
while base in acked:
base += 1
print(f" 窗口左沿推进到 {base},已确认={sorted(acked)}")
print("全部确认完毕。")
if __name__ == '__main__':
random.seed(1)
send_with_window(list(range(10)), win_size=4, drop_idx=6)
4.6 面试追问¶
🧭 答法提示:可靠传输题按「序号 + ACK + 重传 + 窗口」四件套展开,别漏「累计确认」;被问窗口时先分清楚 rwnd(接收方能力)与 cwnd(网络状况),再说发送窗口取两者较小值。
追问 1:累计确认有什么缺点? 标准回答: 一个报文丢失会导致后续所有报文只得到「对缺口前序号的 ACK」,发送方必须重传缺口后的全部数据,效率低;SACK(RFC 2018/2883)通过选项告知「哪些段已收到」,只重传真正丢失的段。
追问 2:RTO 太短或太长会怎样? 标准回答: 太短 → 无辜重传(网络抖动被误判为丢包),浪费带宽;太长 → 丢包恢复慢、吞吐下降。因此 RTO 用 SRTT + 4×RTTVAR 动态跟随网络状态。
追问 3:接收窗口为 0 时发送方怎么办? 标准回答: 发送方停止发送并启动持续计时器(persist timer),周期性发送 1 字节的窗口探测报文(zero-window probe),防止接收方「窗口更新 ACK 丢失」导致死锁。
⚠️ 易错点:流量控制(rwnd)是接收方能力限制,拥塞控制(cwnd)是网络能力限制,两者相乘/取小共同决定发送速率——面试高频辨析题。
5. 流量控制 vs 拥塞控制¶
💡 定义(小白版):拥塞控制是 TCP 自己的一套「怕把网络堵死」的开车策略:慢启动(先少发、每轮翻倍试探)、拥塞避免(接近上限后匀速爬升)、快重传(丢包立刻补)、快恢复(补完不从头再来,只降一半继续走)。 🏷️ 类比:像高速匝道口放行:先一辆一辆放(慢启动),路况看起来通畅就每次加倍放(翻倍),快到怀疑要堵时改匀速放(拥塞避免);有人插队掉了队(丢包)就立刻补位(快重传),队伍缩回去一半继续匀速(快恢复),而不是清空重排。
5.1 定义与区别¶
- 流量控制(Flow Control):端到端的、接收方主导的控制,防止发送方把接收方缓冲区塞爆(
rwnd)。 - 拥塞控制(Congestion Control):网络整体的控制,防止过多数据注入导致路由器队列溢出丢包(
cwnd)。
| 维度 | 流量控制 | 拥塞控制 |
|---|---|---|
| 控制对象 | 发送方 vs 接收方(两端) | 发送方 vs 全网路径 |
| 触发依据 | 接收方通告的 rwnd |
丢包 / 延迟推断网络拥塞 |
| 机制 | 滑动窗口 | 慢启动 / 拥塞避免 / 快重传 / 快恢复 |
| 是否端到端 | 是 | 本质是端到端协作(TCP 层),但面向网络状态 |
5.2 拥塞控制四条线¶
- 慢启动(Slow Start):
cwnd从 1 MSS 开始,每个 RTT 翻倍(指数增长),直到cwnd >= ssthresh。 - 拥塞避免(Congestion Avoidance):进入加性增,每个 RTT
cwnd += 1(线性增长),直到出现丢包。 - 快速重传(Fast Retransmit):收到 3 个冗余 ACK 立即重传丢失段(不等超时)。
- 快速恢复(Fast Recovery):收到 3 个冗余 ACK 时
ssthresh = cwnd / 2,cwnd = ssthresh + 3(进入线性增长);若超时则回到慢启动(cwnd=1,ssthresh 减半)。
5.3 cwnd 随轮次变化示意图(ASCII)¶
cwnd(段)
32 | ____
28 | __/
24 | __/
20 | __/
16 | ____--__/ ← ssthresh=16:停止指数,改线性(+1/RTT)
12 | __/
8 | __/
4 | __/
2 | __/
1 | _/
+---+---+---+---+---+---+---+---+---+---+---+----> RTT 轮次
1 2 3 4 5 6 7 8 9 10 11 12
|----- 慢启动(指数×2) -----|---- 拥塞避免(线性+1) ----|
↑ 收到3个冗余ACK: ssthresh=cwnd/2=8, cwnd=8+3 → 快恢复
5.4 Python 3 可运行示例(cwnd 演化模拟)¶
"""模拟 cwnd 演化:慢启动 → 拥塞避免 → 快恢复(标准库,可直接运行)。"""
def simulate_cwnd(ssthresh=16, loss_round=9, rounds=14):
cwnd, out = 1, []
for r in range(1, rounds + 1):
if r == loss_round: # 第 9 轮出现丢包(3 冗余 ACK)
ssthresh = max(cwnd // 2, 2)
cwnd = ssthresh + 3 # 快恢复:减半 + 3
mode = "快恢复"
elif cwnd < ssthresh:
cwnd *= 2 # 慢启动:指数
mode = "慢启动"
else:
cwnd += 1 # 拥塞避免:线性
mode = "拥塞避免"
out.append((r, cwnd, mode))
return out
if __name__ == '__main__':
for r, c, m in simulate_cwnd():
print(f"RTT={r:>2} cwnd={c:>3} 阶段={m}")
print(f" {'#' * c}")
5.5 面试追问¶
🧭 答法提示:「流量 vs 拥塞」先给一句话结论:「流量控制怕接收方吃不消,拥塞控制怕网络堵车」,再展开 rwnd/cwnd 与四条线;答演进时按「以丢包为信号(Reno 系)→ 以带宽/时延为信号(BBR)」两条脉络记忆。
追问 1:为什么慢启动叫「慢」却指数增长? 标准回答: 指初始值小、增速可控(从 1 开始试探网络容量),指数增长是为了快速逼近可用带宽;一旦超过 ssthresh 就转线性,避免瞬间打爆网络。
追问 2:超时丢包和冗余 ACK 丢包的处理有什么不同?
标准回答: 超时说明网络可能严重拥塞(甚至路径中断),回到慢启动 cwnd=1;3 个冗余 ACK 说明网络还能传数据,只是丢了单个包,用快重传 + 快恢复(减半)更高效。
追问 3:现代拥塞控制算法有哪些演进? 标准回答: Reno(经典四线)、NewReno(改进快恢复、处理多个丢包)、BIC/CUBIC(Linux 默认,按三次曲线增长,适合高带宽长链路)、BBR(Google,基于瓶颈带宽与最小 RTT 探测,不依赖丢包)。
⚠️ 易错点:慢启动阈值 ssthresh 在每次丢包时减半;「快恢复」后不是回到慢启动,而是直接进入拥塞避免(线性),除非发生超时。
6. TCP vs UDP¶
💡 定义(小白版):UDP(用户数据报协议)与 TCP 相反:不发前不握手、不管丢不丢、不管顺序,一个「快递」发出去就是一份完整包裹,丢了就丢了。TCP 定义见第 2 章——可靠但慢;UDP 不可靠但快、延迟低。 🏷️ 类比:TCP 是挂号信(有单号、可查、可补寄);UDP 是明信片(扔进邮筒就走,寄丢了邮局不负责,但便宜、快、谁都能随手写)。看视频直播偶尔花一下屏能忍,所以用明信片(UDP);转账必须分毫不差,只能走挂号信(TCP)。
6.1 对比表¶
| 维度 | TCP | UDP |
|---|---|---|
| 连接性 | 面向连接(三次握手) | 无连接 |
| 可靠性 | 可靠:确认、重传、排序 | 尽力而为,可能丢包乱序 |
| 传输方式 | 字节流 | 数据报(保留报文边界) |
| 流量/拥塞控制 | 有(rwnd/cwnd) | 无 |
| 头部开销 | 20 字节 | 8 字节 |
| 速度 | 较慢 | 快、低延迟 |
| 典型应用 | HTTP/HTTPS、FTP、SMTP、SSH | DNS、视频直播、VoIP、游戏、QUIC |
6.2 各应用场景对照¶
- TCP 场景:需要完整、有序数据的场景——网页、文件传输、邮件、远程登录。
- UDP 场景:容忍少量丢失、追求实时性——DNS 查询(默认)、RTP 音视频、实时游戏、NTP 时间同步、DHCP。
- 注意:HTTP/3 的 QUIC 基于 UDP,改变了「可靠传输必须用 TCP」的刻板印象。
6.3 QUIC 为什么基于 UDP¶
- 突破 TCP 内核僵化:TCP 的演进(如多路复用、0-RTT)需要修改操作系统内核,部署周期长;QUIC 在用户态实现,可随应用快速迭代。
- 消除队头阻塞:TCP 按字节流严格有序,一个包丢失会阻塞后续所有 HTTP 请求(TCP 层队头阻塞);QUIC 内部多路复用,每个流独立可靠传输,一个流丢包不影响其他流。
- 更快建连:TLS 1.3 与传输握手合并,支持 0-RTT / 1-RTT 建连。
- 连接迁移:QUIC 用 Connection ID 而非四元组标识连接,Wi-Fi ↔ 蜂窝切换不断连。
- UDP 只提供「尽力传输 + 端口多路复用」,其余(重传、乱序处理、拥塞控制)由 QUIC 自己在用户态实现。
6.4 Python 3 可运行示例(UDP 收发 + TCP 对比)¶
"""UDP 数据报收发示例(标准库,可直接运行:先开接收端再开发送端)。"""
import socket, threading
def udp_demo():
rx = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
rx.bind(('127.0.0.1', 9999))
tx = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
def recv_loop():
data, addr = rx.recvfrom(1024)
print(f"接收端收到: {data.decode()} 来自 {addr}")
t = threading.Thread(target=recv_loop); t.start()
tx.sendto(b'hello udp', ('127.0.0.1', 9999)) # 无连接,直接发
t.join()
rx.close(); tx.close()
# 对比:TCP 需要 connect 三次握手 + accept,见第 2 节
if __name__ == '__main__':
udp_demo()
6.5 面试追问¶
🧭 答法提示:TCP vs UDP 先给结论「可靠但慢 vs 快但可能丢」,再各举一个应用场景;被问「UDP 能可靠吗」别只说不能,要补「应用层可自行实现可靠传输(RUDP/KCP/QUIC)」。
追问 1:DNS 为什么用 UDP 而不用 TCP? 标准回答: 查询报文小、一次往返即可完成,UDP 开销低、速度快;但区域传送(AXFR)和响应超过 512/4096 字节(EDNS)时会改用 TCP 保证可靠与完整。
追问 2:UDP 如何实现可靠传输? 标准回答: 在应用层自行实现——序号 + ACK + 重传 + 滑动窗口(如 RUDP、KCP),或直接使用 QUIC(在 UDP 之上实现 TLS + 可靠流 + 拥塞控制)。
追问 3:为什么视频直播用 UDP 却感觉「不卡」? 标准回答: 视频可以容忍少量丢包(丢帧后解码器可跳过或用前向纠错 FEC 恢复),且要低延迟;TCP 的可靠重传会引入延迟与卡顿,反而体验更差。
⚠️ 易错点:TCP 是字节流无报文边界,UDP 是数据报有边界——「TCP 粘包问题」正源于此,UDP 天然不存在粘包。
7. HTTP 报文结构、方法与状态码¶
💡 定义(小白版):HTTP 无状态 = 服务器记不住你:每一次请求都是「陌生人来电」,服务器既不记得上次聊了什么,也不记得你是谁,只能从请求里现认。 🏷️ 类比:像一次性服务的快餐店店员:每个顾客来了都重新点单,他不存「这位顾客上次点了辣还是微辣」。要记住你,就得靠后面讲的 Cookie/Session/Token(第 12 章附录)把「小纸条」带在身上。
7.1 报文结构¶
请求报文(四部分:请求行 / 请求头 / 空行 / 请求体):
GET /index.html HTTP/1.1\r\n
Host: www.example.com\r\n
User-Agent: curl/8.0\r\n
Accept: */*\r\n
\r\n
(请求体,GET 通常为空)
响应报文(状态行 / 响应头 / 空行 / 响应体):
HTTP/1.1 200 OK\r\n
Content-Type: text/html; charset=utf-8\r\n
Content-Length: 1234\r\n
\r\n
<html>...</html>
7.2 GET vs POST 对比表¶
| 维度 | GET | POST |
|---|---|---|
| 语义 | 获取资源(安全、幂等、可缓存) | 提交/创建资源(非幂等) |
| 参数位置 | URL 查询字符串(可见、有长度限制) | 请求体(相对隐蔽,无长度限制) |
| 缓存 | 可被浏览器/代理缓存 | 默认不可缓存(需显式响应头) |
| 回退/刷新 | 安全,可重复执行 | 可能重复提交(需防重) |
| 典型场景 | 搜索、翻页、下载 | 登录、下单、上传 |
REST 语义下,还有 PUT(整体替换,幂等)/ PATCH(局部修改)/ DELETE(删除)/ HEAD(只取头)/ OPTIONS(探测能力,CORS 预检)。
7.3 状态码分类¶
| 分类 | 含义 | 常见值 |
|---|---|---|
| 2xx | 成功 | 200 OK、201 Created、204 No Content |
| 3xx | 重定向 | 301 永久、302 临时、304 Not Modified(缓存)、307/308 |
| 4xx | 客户端错误 | 400 Bad Request、401 未认证、403 无权限、404 不存在、405 方法不允许、429 限流 |
| 5xx | 服务端错误 | 500 内部错误、502 网关错误(上游无响应)、503 服务不可用、504 网关超时 |
7.4 Python 3 可运行示例(发送 GET/POST 并打印状态)¶
"""用标准库 urllib 演示 GET/POST 与状态码处理(可直接运行)。"""
import urllib.request, urllib.error
def fetch(method: str, url: str, data: bytes = None):
req = urllib.request.Request(url, data=data, method=method)
try:
with urllib.request.urlopen(req, timeout=5) as resp:
print(f"{method} {url} -> {resp.status} {resp.reason}")
print("响应头:", dict(resp.headers)["Content-Type"])
print("响应体前 100 字节:", resp.read(100))
except urllib.error.HTTPError as e:
print(f"{method} {url} -> 错误 {e.code}: {e.reason}")
if __name__ == '__main__':
fetch("GET", "https://httpbin.org/get?a=1")
fetch("POST", "https://httpbin.org/post", b'{"k": "v"}')
fetch("GET", "https://httpbin.org/status/404") # 演示 404
7.5 面试追问¶
🧭 答法提示:状态码题用「3 个主类各举一例」开头(2xx/4xx/5xx),再讲易混对:301/302、401/403、204/304;被问幂等性先给定义「重复执行结果一致」,再列 GET/PUT/DELETE 幂等、POST 不幂等。
追问 1:301 和 302 的区别? 标准回答: 301 是永久重定向,浏览器和搜索引擎会缓存新地址,后续直接访问新 URL;302 是临时重定向,每次仍需访问原地址。307/308 则保证不改变请求方法(302 在部分客户端会把 POST 转成 GET)。
追问 2:401 与 403 的区别?
标准回答: 401 = 未认证(不知道你是谁,需登录/token),响应头带 WWW-Authenticate;403 = 已认证但无权限(知道你但禁止访问)。
追问 3:什么情况下返回 304?
标准回答: 客户端带 If-Modified-Since / If-None-Match 做条件请求,服务端判断资源未变化时返回 304 Not Modified(无响应体),配合缓存(见第 11 节)减少传输。
⚠️ 易错点:204 No Content 与 304 都没有响应体,但 204 表示「处理成功且无内容返回」,304 表示「用缓存,不用返回」——语义不同。
8. HTTP 1.0 / 1.1 / 2 / 3 演进¶
💡 定义(小白版):短连接 = 每次请求都重新「拨号、通话、挂断」(HTTP/1.0 默认);长连接 = 打完一个请求不断线,下个请求直接接着说(HTTP/1.1 的 Keep-Alive),省去反复握手的开销。 🏷️ 类比:短连接像每次买东西都重新排队结账;长连接像和老顾客开个赊账口子:这次问完价下次接着问,不用再排一次队,但也不能一直占着柜台不放(有超时限制)。
8.1 各版本核心特性¶
| 版本 | 核心改进 | 遗留问题 |
|---|---|---|
| HTTP/1.0 | 基础报文;每次请求新建 TCP 连接,用完即断 | 连接开销大,串行请求慢 |
| HTTP/1.1 | Keep-Alive 长连接(默认)、管线化(Pipelining)、Host 头、分块传输 | 管线化要求响应按序返回 → 队头阻塞;头部重复冗余 |
| HTTP/2 | 二进制分帧、多路复用、HPACK 头部压缩、服务器推送、流优先级 | TCP 层队头阻塞仍存在;握手延迟 |
| HTTP/3 | 基于 QUIC(UDP),流独立消除队头阻塞、0-RTT 建连、连接迁移 | 需 UDP 支持,兼容性仍在推广中 |
8.2 队头阻塞(Head-of-Line Blocking)¶
- HTTP/1.1 管线化队头阻塞(HTTP 层):多个请求共用一条 TCP 连接,响应必须按发送顺序返回,第一个响应慢,后续全部被堵 → 已被浏览器禁用管线化,改为多连接(每域名 6 条左右)。
- HTTP/2 多路复用:把请求/响应拆成帧交错传输,逻辑上解决了 HTTP 层队头阻塞。
- TCP 层队头阻塞(HTTP/2 仍存在):TCP 是字节流,一个 TCP 包丢失,接收缓冲区里后续所有帧都无法按序交付给应用层,即使其他流的数据已到达 → 仍需等待重传。
- HTTP/3 的解法:QUIC 在 UDP 之上按流独立传输与重传,一个流的丢包只阻塞该流 → 彻底消除队头阻塞。
8.3 HPACK 头部压缩与二进制分帧¶
- 二进制分帧:HTTP/2 将报文拆成帧(Frame),帧携带流标识(Stream ID),同一连接上多个流的帧交错发送 → 实现多路复用。
- HPACK:① 静态表(61 个高频头字段映射到固定索引);② 动态表(连接内已发送头部建索引,后续用索引引用);③ 哈夫曼编码压缩字面值 → 头部体积大幅下降。
8.4 Python 3 可运行示例(对比 HTTP/1.1 与 HTTP/2 请求)¶
"""演示 HTTP/1.1 与 HTTP/2 的差异(标准库 urllib 走 HTTP/1.1;httpx 可选装)。
可直接运行:打印 httpbin 响应与协议版本。"""
import urllib.request, ssl
def h1_demo():
ctx = ssl.create_default_context()
req = urllib.request.Request("https://httpbin.org/get", headers={"User-Agent": "py"})
with urllib.request.urlopen(req, context=ctx, timeout=5) as r:
print("HTTP/1.1 响应状态:", r.status, "| 头部:", dict(r.headers)["Server"])
if __name__ == '__main__':
h1_demo()
# HTTP/2 验证:安装 httpx 后执行以下代码
# import httpx
# with httpx.Client(http2=True) as c:
# r = c.get("https://httpbin.org/get")
# print("HTTP/2 响应:", r.status_code, "协议:", r.http_version)
8.5 面试追问¶
🧭 答法提示:演进题按「版本 → 核心改进 → 遗留问题」排比作答;队头阻塞必答「HTTP 层 vs TCP 层」两层,先点明 HTTP/2 只解决了前者,再说 HTTP/3 靠 QUIC 按流独立传输解决后者。
追问 1:HTTP/2 还有队头阻塞吗? 标准回答: 有——TCP 层队头阻塞。TCP 按字节流严格有序,单个包丢失会导致接收缓冲区的后续数据无法交付应用层;HTTP/2 只解决了 HTTP 层的队头阻塞。
追问 2:为什么 HTTP/3 不用 TCP 实现同样的功能? 标准回答: TCP 的行为由操作系统内核决定,难以快速演进;且 TCP 流模型天然无法做到流间独立(一个字节流)。QUIC 在用户态 UDP 上自定义多流可靠传输,兼顾演进速度与消除队头阻塞。
追问 3:Keep-Alive 和 HTTP/2 多路复用的区别? 标准回答: Keep-Alive 只是复用连接,请求仍然串行;多路复用是在一条连接内并发传输多个请求/响应(帧交错),并发度大幅提升。
⚠️ 易错点:HTTP/2 的「多路复用」解决的是 HTTP 层队头阻塞,TCP 层队头阻塞要等 HTTP/3/QUIC 才解决——面试官常在这个点挖坑。
9. HTTPS 与 TLS¶
💡 定义(小白版):HTTPS = HTTP + TLS(传输层安全协议):在普通 HTTP 外面再套一层「加密隧道」,让中间人看到的是乱码,同时还能证明对面就是真网站。 🏷️ 类比:HTTP 是明信片(谁都能看);HTTPS 是带密码锁的保险箱寄件(只有收发双方有钥匙),外加快递员验明正身(证书),防止有人偷看或冒充。
9.1 对称 / 非对称加密¶
| 类型 | 密钥 | 速度 | 用途 |
|---|---|---|---|
| 对称加密(AES、ChaCha20) | 双方用同一把密钥 | 快 | 加密实际数据 |
| 非对称加密(RSA、ECC) | 公钥加密/私钥解密(反之签名) | 慢(百倍级差距) | 密钥交换、数字签名、身份认证 |
9.2 为什么混合加密¶
- 只用对称:密钥如何安全送达对方?网络上传输密钥本身会被窃听。
- 只用非对称:速度太慢,无法承载海量数据。
- 混合加密:用非对称加密安全地协商出会话密钥(前向安全可用 ECDHE),之后用对称加密传输业务数据——兼顾安全与性能。
9.3 TLS 1.2 握手流程(详细步骤)¶
客户端 服务端
|--- ① ClientHello (TLS版本/随机数/密码套件列表) --->|
|<-- ② ServerHello (选定版本/随机数/密码套件) -------|
|<-- ③ Certificate (服务端证书,含公钥) ------------|
|<-- ④ ServerKeyExchange (ECDHE 参数) + ServerHelloDone -|
|--- ⑤ ClientKeyExchange (客户端 ECDHE 参数) ------->|
|--- ⑥ ChangeCipherSpec + Finished(加密的握手摘要) -->|
|<-- ⑦ ChangeCipherSpec + Finished -----------------|
|=== ⑧ 后续应用数据用协商出的对称密钥加密传输 =======|
- ClientHello:客户端生成随机数
client_random,声明支持的 TLS 版本与密码套件。 - ServerHello:服务端选定版本与套件,返回随机数
server_random。 - Certificate:服务端下发证书(公钥 + CA 签名)。
- ServerKeyExchange:ECDHE 模式下交换椭圆曲线参数;随后 ServerHelloDone。
- ClientKeyExchange:客户端交换自己的 ECDHE 参数,双方各自算出相同的预主密钥(pre-master secret)→ 用
client_random + server_random + pre-master派生会话密钥。 - 客户端发 ChangeCipherSpec(通知切换加密)并发送 Finished(对之前所有握手消息的 MAC 摘要,用新密钥加密)。
- 服务端同样发送 ChangeCipherSpec + Finished 并校验摘要。
- 握手完成,之后全部用对称密钥加密。
TLS 1.3 简化为 1-RTT(合并步骤),且移除 RSA 密钥交换(仅保留 ECDHE/DHE,保证前向安全),并支持 0-RTT 恢复。
9.4 证书链与 CA¶
- CA(证书颁发机构) 是受信任的第三方,用自己的私钥给服务器证书签名;
- 证书链:服务器证书 ← 中间 CA 证书 ← 根 CA 证书(浏览器内置信任根);
- 校验过程:用上一级公钥验证下一级证书签名,直到内置根证书;同时检查域名匹配、有效期、吊销状态(OCSP/CRL);
- 任一环节失败 → 浏览器警告「证书不受信任」。
9.5 Python 3 可运行示例(获取并打印证书链)¶
"""使用标准库 ssl 获取 https://www.baidu.com 的证书链(可直接运行)。"""
import ssl, socket
host, port = 'www.baidu.com', 443
ctx = ssl.create_default_context()
with socket.create_connection((host, port), timeout=5) as sock:
with ctx.wrap_socket(sock, server_hostname=host) as ssock:
print("协商 TLS 版本:", ssock.version())
print("密码套件:", ssock.cipher())
for i, cert in enumerate(ssock.get_peer_cert_chain() or []):
import datetime
# cert 为 ASN.1 字典,常见字段如下
print(f"证书[{i}] subject: {cert.get('subject')}")
print(f" issuer : {cert.get('issuer')}")
9.6 面试追问¶
🧭 答法提示:TLS 题先答「混合加密:非对称协商密钥 + 对称加密数据」,再按「Hello → 证书 → 密钥交换」三步讲握手骨架;被问 HTTPS 是否绝对安全,先答「传输层安全,但信任链(证书)和客户端行为仍有漏洞」。
追问 1:为什么 ECDHE 优于传统 RSA 密钥交换? 标准回答: RSA 密钥交换把私钥用于解密协商,一旦私钥泄露,历史上所有录制的流量都能被解密(无前向安全);ECDHE 每次会话的临时密钥用完即弃,前向安全,私钥泄露不影响历史流量。
追问 2:中间人攻击如何被 TLS 阻止? 标准回答: 中间人无法伪造「受信任 CA 签发的证书」——即使截获 ClientHello 并伪造证书,客户端校验证书链/域名/签名会失败;若用户忽略警告,攻击才能得逞(因此要教育用户不点「继续访问」)。
追问 3:HTTPS 一定安全吗? 标准回答: 传输加密是安全的,但仍有攻击面:证书被错误信任(私有 CA 被攻破)、降级攻击(强制回退 TLS1.0)、HSTS 缺失(首次访问被降级为 HTTP)、服务端私钥泄露等。
⚠️ 易错点:握手过程本身前几轮是明文(ClientHello/ServerHello 不加密),泄露的是版本与随机数(无害);真正需要保密的是 pre-master secret,它从不以明文传输。
10. DNS 解析完整流程与 CDN¶
💡 定义(小白版):DNS(域名系统)是「网址 → IP 的翻译官」:人记
www.baidu.com好记,电脑只认183.2.172.177这样的数字,DNS 负责把两者对上。递归查询 = 本地 DNS 替你跑腿,一次问完拿结果;迭代查询 = 本地 DNS 自己一级级问路(根 → 顶级 → 权威),每级只告诉它「下一站去哪问」。 🏷️ 类比:问「XX 大学在哪里」:递归像你问一位全知的前台,前台跑遍各部门后把结论告诉你;迭代像你问门卫,门卫说「去问教务处」,教务处说「去问系办」,你自己一级级跑完才拿到答案。
10.1 定义¶
DNS(Domain Name System) 将域名映射为 IP 地址,是分布式、层次化的命名系统。端口 53,默认 UDP,大响应/区域传送用 TCP。
10.2 查询方式¶
- 递归查询(Recursive):客户端 → 本地 DNS 服务器;本地服务器替客户端逐级向上查询,最终把结果返回给客户端。
- 迭代查询(Iterative):本地 DNS 服务器 → 根/顶级/权威服务器时,被返回「下一级服务器地址」,自己再发起新查询,逐级逼近答案。
10.3 完整解析流程(伪代码)¶
1. 客户端查浏览器缓存 → 未命中
2. 查操作系统 hosts / 系统缓存 → 未命中
3. 向本地 DNS 服务器(如 114.114.114.114)发起【递归查询】
4. 本地 DNS 向【根服务器 .】发起【迭代查询】
→ 根返回 .com 顶级域服务器地址
5. 本地 DNS 向【.com 顶级服务器】查询
→ 返回 example.com 权威服务器地址
6. 本地 DNS 向【example.com 权威服务器】查询
→ 返回 A/AAAA 记录(含 TTL)
7. 本地 DNS 缓存结果(TTL 内),并递归返回给客户端
8. 客户端拿到 IP,缓存并建立连接
10.4 DNS 与 CDN 的关系¶
- CDN(内容分发网络):把内容缓存到离用户最近的边缘节点。
- 关键机制:网站通过 CNAME 记录把
cdn.example.com指向 CDN 服务商的域名; - 本地 DNS 解析到 CDN 服务商的 GSLB(全局负载均衡) 后,GSLB 根据用户来源 IP / 地理 / 负载 / 网络状况返回最优边缘节点 IP;
- 因此 CDN 依赖 DNS 做智能调度(DNS 劫持 CDN 调度也可被污染——所以有 HTTPDNS 方案,用 HTTP 查询绕过本地 DNS)。
10.5 Python 3 可运行示例(域名解析)¶
"""标准库 socket 演示 DNS 解析(可直接运行)。"""
import socket
def resolve(domain):
try:
infos = socket.getaddrinfo(domain, 80)
ips = sorted({info[4][0] for info in infos})
print(f"{domain} 解析到 {len(ips)} 个 IP:")
for ip in ips:
print(" ", ip)
except socket.gaierror as e:
print(f"解析失败: {e}")
if __name__ == '__main__':
resolve('www.baidu.com')
resolve('www.google.com') # 可能因网络环境失败,属预期
10.6 面试追问¶
🧭 答法提示:DNS 题先区分「递归 = 替客户端跑腿、迭代 = 逐级问路」,再用「浏览器缓存 → 本地 DNS → 根 / 顶级 / 权威」串一遍流程;CDN 题必提 CNAME → GSLB 就近调度,答出「短 TTL 利于故障切换」是加分点。
追问 1:递归查询和迭代查询的主角分别是谁? 标准回答: 递归查询的主角是本地 DNS 服务器(替客户端跑腿);迭代查询的主角是本地 DNS 服务器与各级权威服务器之间逐级「问路」。客户端只向本地 DNS 发一次递归查询。
追问 2:DNS 缓存与 TTL 的作用? 标准回答: TTL 决定记录在缓存中的存活时间,减少权威服务器压力、加快解析;但 TTL 过长会导致变更生效慢(换 IP 后旧 IP 仍被访问),CDN 故障切换常用短 TTL(如 30s)。
追问 3:DNS 污染/劫持怎么办? 标准回答: 使用 HTTPDNS(通过 HTTPS 从服务商 API 拿 IP,绕过本地 DNS)、DoH/DoT(DNS over HTTPS/TLS 加密查询)、多 DNS 备份与监控切换。
⚠️ 易错点:根服务器只有 13 个逻辑 IP(任播部署多台物理机);「DNS 解析」返回的可能是 CNAME 链而非最终 A 记录,CDN 调度正是利用 CNAME 实现的。
11. 经典综合题:输入 URL 到页面显示¶
💡 定义(小白版):这题是把前面所有章节串成一条流水线:你在地址栏敲下网址回车后,浏览器依次做「查域名(DNS)→ 建管道(TCP 握手)→ 上锁(TLS)→ 发请求(HTTP)→ 等响应 → 画页面(渲染)」,每步能省则省(命中缓存就跳过)。 🏷️ 类比:像点外卖:先查这家店在哪个位置(DNS)→ 叫车(TCP 建连)→ 锁好餐盒防偷看(TLS)→ 下单(HTTP 请求)→ 骑手送货(网络传输)→ 你拆箱开吃(浏览器渲染)。哪步能走近道(缓存)就走近道。
11.1 完整过程(含每一层缓存)¶
- 输入与解析 URL:浏览器解析协议(https)、域名、端口、路径、参数;做 HSTS 检查、安全检查(XSS 过滤等)。
- DNS 解析(第 10 节):查 浏览器缓存 → 系统 hosts/OS 缓存 → 本地 DNS(递归)→ 根/顶级/权威(迭代);命中 CDN 时由 GSLB 返回边缘节点 IP。
- 建立 TCP 连接:三次握手(第 2 节);HTTP/2/3 则多路复用或 QUIC 0-RTT 建连。
- TLS 握手(HTTPS):协商版本与套件、证书校验、密钥交换(第 9 节)。
- 发送 HTTP 请求:组装请求报文;查 浏览器 HTTP 缓存(强缓存 Expires/Cache-Control)——命中直接使用缓存(不发请求);否则带条件请求头走协商缓存(ETag/Last-Modified),命中返回 304。
- 网络传输:请求经网卡 → 交换机 → 路由器 → 运营商骨干 → CDN/源站;沿途有 代理缓存/CDN 缓存。
- 服务器处理:负载均衡(Nginx/LVS)转发 → Web 服务器(Nginx/Tomcat)→ 应用逻辑 → 数据库/缓存(Redis)→ 生成响应。
- 返回响应:状态行 + 响应头 + 响应体;CDN 层可缓存静态资源(CSS/JS/图片)。
- 浏览器渲染:解析 HTML → DOM 树;解析 CSS → CSSOM;合并成渲染树;布局(Layout)→ 绘制(Paint)→ 合成(Composite);JS 执行(可能阻塞解析,异步脚本不阻塞)。
- 后续资源加载:并发加载 CSS/JS/图片(HTTP/2 多路复用);触发二次请求(懒加载、API 调用)。
11.2 缓存层级速查表(每层都列)¶
| 层级 | 缓存内容 | 失效依据 |
|---|---|---|
| 浏览器缓存(内存/磁盘) | 已访问页面资源 | Cache-Control/Expires/ETag |
| 系统/浏览器 DNS 缓存 | 域名→IP | TTL |
| 本地 DNS 服务器缓存 | 域名→IP | TTL |
| CDN 边缘节点 | 静态资源 | 源站回源策略/TTL |
| 反向代理(Nginx) | 静态资源/微服务响应 | proxy_cache 配置 |
| 应用层缓存(Redis) | 热点数据 | 过期/淘汰策略 |
| 数据库缓存/页缓存 | 数据页 | Buffer Pool |
11.3 Python 3 可运行示例(模拟带缓存的全过程)¶
"""模拟 URL 访问全过程的状态流转(标准库,可直接运行)。"""
CACHE = {"www.example.com/index.html": "<html>Hello</html>"}
def visit(url):
steps = []
# 1. 解析
domain, path = url.split('/')[2], '/' + '/'.join(url.split('/')[3:])
steps.append(f"解析 URL: domain={domain}, path={path}")
# 2. DNS(查缓存)
steps.append("DNS: 浏览器缓存命中" if domain in ("www.example.com",)
else "DNS: 递归+迭代解析")
# 3. TCP 三次握手
steps.append("TCP: 三次握手完成 (SYN → SYN+ACK → ACK)")
# 4. TLS
if url.startswith("https"):
steps.append("TLS: 证书校验通过, ECDHE 密钥协商完成")
# 5. HTTP 缓存
if path in CACHE:
steps.append(f"HTTP缓存: 命中 (304/直接用缓存), 响应体 {len(CACHE[path])} 字节")
else:
steps.append("HTTP缓存: 未命中, 发送请求到源站")
# 6-8. 传输与服务器
steps.append("传输: 经交换机/路由器/CDN 到达源站 → 生成响应 200 OK")
# 9. 渲染
steps.append("渲染: HTML→DOM, CSS→CSSOM, 布局→绘制→合成")
return steps
if __name__ == '__main__':
for s in visit("https://www.example.com/index.html"):
print("->", s)
11.4 面试追问¶
🧭 答法提示:按「DNS → TCP → TLS → HTTP → 渲染」时间线作答,每步主动报缓存层(DNS / 浏览器 / CDN / 应用);被问如何提速,从「预解析(dns-prefetch)、预连接(preconnect)、资源压缩合并、CDN 就近」四个词展开足够。
追问 1:强缓存与协商缓存的区别?
标准回答: 强缓存(Cache-Control: max-age / Expires)命中后不发请求直接使用;协商缓存(ETag / Last-Modified)需发请求,服务器返回 304 才用缓存。优先级:Cache-Control > Expires;ETag 比 Last-Modified 更精确(秒级粒度问题)。
追问 2:浏览器最多对一个域名开几条 TCP 连接? 标准回答: 现代浏览器 HTTP/1.1 下通常 6 条左右(视浏览器而异),这就是 HTTP/1.1 时代「域名分片」优化存在的原因;HTTP/2 一条连接多路复用后不再需要分片。
追问 3:从输入 URL 到首屏最快的方式有哪些?
标准回答: DNS 预解析(dns-prefetch)、TCP+TLS 预连接(preconnect)、关键资源预加载(preload)、HTTP/2 多路复用、CDN 就近缓存、服务端渲染/流式渲染、资源压缩与合并。
⚠️ 易错点:面试答「输入 URL 全过程」时必须按层展开缓存(DNS 缓存、浏览器缓存、CDN 缓存、应用缓存),只答「DNS→TCP→HTTP→渲染」会被认为不深入。
附:高频速记表(考前 5 分钟)¶
| 考点 | 一句话答案 |
|---|---|
| 为什么三次握手 | 防历史连接 + 确认双方收发能力,2 次不够、4 次浪费 |
| 为什么四次挥手 | 全双工 + 半关闭,ACK 与 FIN 必然分离 |
| TIME_WAIT 2MSL | 保证最后 ACK 可重传 + 防旧报文串扰 |
| 流量 vs 拥塞控制 | 接收方能力 vs 网络能力;rwnd vs cwnd |
| 快恢复 | ssthresh=cwnd/2,cwnd=ssthresh+3,线性增长 |
| HTTP/2 队头阻塞 | 仍有 TCP 层队头阻塞;HTTP/3/QUIC 消除 |
| 混合加密 | 非对称协商密钥 + 对称加密数据(兼顾安全与性能) |
| CDN 调度 | CNAME → GSLB 按地理位置/负载返回最优节点 |
祝顺利上岸!本笔记配套仓库:
autumn-recruit-algo/05-八股与工程/。