05.9 阶段 8 高并发进阶(可选,面向中高级岗位)
本页目录
一、阶段定位
这是整条路径的最后一个阶段,面向中高级岗位与"要做网关/消息中间件/高并发服务"的人。前七个阶段解决"怎么写一个正确的服务",本阶段解决"怎么在单机 1 万 QPS、10 万连接下不抖"。内容不是必学——如果你的业务是后台管理系统,QPS 几十,本阶段可以跳过;如果目标是网关、推送、实时通信、大促交易,本阶段必须扎实。
与前后阶段的衔接:
- 往上接阶段 3 的 GMP 与 goroutine:高并发不是"无限起 goroutine",要受控。
- 往上接阶段 4 的 pprof 与 GC 调优:压测时看 CPU、heap、block、trace。
- 往上接阶段 6 的连接池:DB 连接池、Redis 连接池是高并发的第一瓶颈。
- 往上接阶段 7 的指标:压测要看 Prometheus 的 P99、错误率、GC 停顿。
原提纲里的"卡点"展开成可判断的现象依据:
- 把高并发等同于加 goroutine:起 1 万个 goroutine 调 DB,结果 DB 连接池打满,P99 飙到 5 秒。
- 不看内核参数:以为 Go 能支持百万连接,实际
ulimit -n是 1024,连接被拒。 - 压测模型与生产流量分布不符:压测 100% 读,生产是 70% 读 30% 写,结果上线后 DB 被打挂。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能解释为什么不能无限起 goroutine,给出受控并发的方案 | 用 worker pool 或 semaphore 把并发 DB 调用限制在 20 |
| 能实现令牌桶限流,并说明与漏桶、滑动窗口的取舍 | 一个接口在 100 QPS 时限流,超过返回 429 |
| 能解释 Go 的 netpoll 如何基于 epoll 实现高并发连接 | 画出"连接 → netpoll → goroutine"的流程 |
| 能调内核参数(ulimit、somaxconn、tcp_tw_reuse)支持 10 万连接 | 压测到 10 万连接无 too many open files |
| 能用 pprof + trace 定位一次 P99 尖刺 | 给出火焰图与根因分析 |
| 能设计压测模型,区分 CPU 密集与 IO 密集的调优方向 | 对一个接口给出 QPS、P99、GC 停顿数据 |
建议学时:
- 全职:2–3 周,约 60–70 小时。限流与并发控制 15 小时、netpoll 与内核 15 小时、压测与 profile 25 小时、GC 调优 10 小时。
- 在职:5–6 周,约 70 小时。压测与 profile 单独占两周。
学时分配建议:并发控制 15%、限流算法 15%、netpoll 与内核参数 20%、GC 调优 15%、压测与瓶颈定位 35%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| GMP 与 goroutine | 能画 G/M/P 与 work stealing | 05.4 的 5.1 节 |
| context 与 channel | 能写带取消的 worker pool | 05.4 的 5.6 节 |
| pprof | 能抓 CPU/heap/block profile | 05.5 的 5.5 节 |
| GC 调优 | 能设 GOGC/GOMEMLIMIT | 05.5 的 5.3 节 |
| 连接池 | 能配置 DB/Redis 连接池 | 05.7 的 5.1 节 |
| 指标 | 能埋 P99 Histogram | 05.8 的 5.2 节 |
经验判断:有 Java 经验的人容易把线程池思维搬过来,到处建固定大小池;有 C 经验的人容易直接操作 epoll 而忽略 Go 的 netpoll 已经封装好。本阶段以"用 Go 的方式做高并发"为目标。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 并发控制 | worker pool、semaphore、通道限并发 | 能讲清原理 | 09.1 高并发基础 |
| 限流算法 | 令牌桶、漏桶、滑动窗口、全局限流 | 能讲清原理 | 09.2 流量治理 |
| netpoll | epoll/kqueue、连接模型、goroutine-per-connection | 了解 | 09.1 高并发基础 |
| 内核参数 | ulimit、somaxconn、tcp_tw_reuse、fd | 会用 | 09.1 高并发基础 |
| GC 调优 | GOGC、GOMEMLIMIT、GC 停顿、CPU 与内存权衡 | 会用 | 09.1 高并发基础 |
| 压测 | 压测模型、QPS、P99、瓶颈定位 | 能讲清原理 | 09.2 流量治理 |
| 熔断降级 | 错误率阈值、半开、降级返回 | 了解 | 09.2 流量治理 |
进度管理建议:限流与压测是中高级面试高频,必须到"能讲清原理";netpoll 与内核参数要求"了解",能说清原理即可。
五、分模块精讲
5.1 并发控制:worker pool 与 semaphore
为什么需要它:无限起 goroutine 调 DB,连接池瞬间打满。正确做法是用 semaphore 限制同时在跑的 DB 调用数量,而不是限制 goroutine 总数。
核心机制:
- 反模式:
for id := range ids { go func() { db.Query(id) }() }—— 1000 个 id 就 1000 个并发 DB 查询。 - semaphore:用带缓冲 channel 做信号量,容量 = 最大并发数。
- worker pool:固定 N 个 worker 从任务队列取任务,适合任务量大、可排队。
- 选择:任务轻、可排队用 semaphore;任务重、需要复用 goroutine 用 worker pool。
- 并发度与连接池对齐:DB MaxOpenConns=20,semaphore 容量就 20,不要让请求排队超过连接池。
最小可运行示例:
package main
import (
"context"
"sync"
)
func fetchUsers(ctx context.Context, ids []string, db *sql.DB) ([]User, error) {
sem := make(chan struct{}, 20) // 最多 20 个并发 DB 查询
results := make([]User, len(ids))
var wg sync.WaitGroup
for i, id := range ids {
wg.Add(1)
go func(i int, id string) {
defer wg.Done()
sem <- struct{}{} // 获取信号量
defer func() { <-sem }() // 释放
u, err := queryUser(ctx, db, id)
if err != nil {
return
}
results[i] = u
}(i, id)
}
wg.Wait()
return results, nil
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| DB 连接池打满 | 无限起 goroutine | 用 semaphore 限制并发 ≤ MaxOpenConns |
| semaphore 容量设太大 | 比 DB 连接池还大 | 对齐连接池参数 |
| goroutine 泄漏 | 任务 channel 不 close | 发送完任务 close,worker range 退出 |
面试考法:"怎么限制并发 DB 调用""semaphore 与 worker pool 区别"。要点:带缓冲 channel 做信号量;并发度对齐连接池;worker pool 复用 goroutine。
5.2 限流算法:令牌桶、漏桶、滑动窗口
为什么需要它:下游服务容量有限,入口必须限流。三种算法各有取舍:令牌桶允许突发、漏桶平滑、滑动窗口精确。
核心机制:
- 令牌桶:固定速率往桶里放令牌,请求取令牌;桶容量允许突发。Go 标准
golang.org/x/time/rate就是令牌桶。 - 漏桶:请求进桶,按固定速率流出;输出速率恒定,适合保护下游。
- 滑动窗口:把时间分成小格子,统计最近窗口内请求数;比固定窗口更精确。
- 限流位置:入口(保护自己)、下游调用(保护下游);全局限流在网关,单实例限流在应用。
- 限流响应:HTTP 429 +
Retry-After;gRPC 用codes.ResourceExhausted。
最小可运行示例:
package main
import (
"net/http"
"golang.org/x/time/rate"
)
// 令牌桶:100 QPS,桶容量 200(允许突发 200)
var limiter = rate.NewLimiter(100, 200)
func Limit(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !limiter.Allow() {
w.Header().Set("Retry-After", "1")
http.Error(w, "too many requests", http.StatusTooManyRequests)
return
}
next.ServeHTTP(w, r)
})
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 限流太严,正常请求被拒 | QPS 设太低 | 按压测结果调;分接口限流 |
| 突发流量打垮下游 | 漏桶没用,令牌桶允许突发 | 对下游调用用漏桶 |
| 限流后返回 500 | 错误码不对 | 用 429,不要 500 |
面试考法:"令牌桶与漏桶区别""滑动窗口解决什么问题""限流返回什么码"。要点:令牌桶允许突发、漏桶平滑;滑动窗口比固定窗口精确;429 + Retry-After。
5.3 netpoll 与高并发连接模型
为什么需要它:Go 能轻松支持几万并发连接,靠的是 netpoll 把网络 IO 与 goroutine 解耦。理解它能解释"为什么 Go 不需要像 Java 那样开线程池"。
核心机制:
- 传统 BIO:一个连接一个线程,线程数 = 连接数,1 万连接要 1 万线程。
- NIO/epoll:一个线程管理所有连接,事件驱动。
- Go 的模型:每个连接一个 goroutine,但 goroutine 在等网络 IO 时被挂起(不是阻塞 OS 线程),M 释放给其他 G。
- netpoll:Go 运行时把 fd 注册到 epoll(Linux)/kqueue(macOS),连接可读时唤醒对应 goroutine。
- 所以 Go 可以跑 10 万 goroutine,而 OS 线程只有几十个。
最小可运行示例:
package main
import (
"io"
"net/http"
)
func main() {
// 每个连接一个 goroutine,但 goroutine 在 IO 时挂起,不占 M
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
io.Copy(w, r.Body) // IO 时 goroutine 挂起,netpoll 等事件
})
_ = http.ListenAndServe(":8080", nil)
}
# 压测 1 万并发连接
# wrk -t4 -c10000 -d30s http://127.0.0.1:8080/
# 看进程 goroutine 数
# curl http://127.0.0.1:6060/debug/pprof/goroutine?debug=1 | head
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 1 万连接时内存暴涨 | 每个 goroutine 栈 2 KB,10 万就是 200 MB | 正常;加 GOMEMLIMIT |
连接被拒 too many open files |
ulimit 太小 | 调 ulimit -n 到 100000 |
| CPU 不高但延迟抖 | goroutine 阻塞在锁 | 抓 block profile |
面试考法:"Go 怎么支持高并发连接""netpoll 是什么""为什么不需要线程池"。要点:goroutine 在 IO 时挂起不占 M;netpoll 基于 epoll;每连接一个 goroutine 但内存轻。
5.4 文件描述符与内核参数
为什么需要它:10 万连接 = 10 万个文件描述符(fd)。Linux 默认 ulimit -n 是 1024,连接上去就报 too many open files。
核心机制:
- fd 上限:
ulimit -n(进程级)、/proc/sys/fs/file-max(系统级)。 somaxconn:TCP 全连接队列长度,默认 128,高并发要调到 4096。tcp_tw_reuse:TIME_WAIT 状态的连接复用,避免端口耗尽。tcp_max_syn_backlog:半连接队列。- K8s 容器里要在 SecurityContext 或 initContainer 调 ulimit,或用 privileged。
最小可运行示例:
# Linux 主机调参
ulimit -n 100000
sysctl -w net.core.somaxconn=4096
sysctl -w net.ipv4.tcp_tw_reuse=1
sysctl -w net.ipv4.tcp_max_syn_backlog=4096
# 验证
ulimit -n
cat /proc/sys/net/core/somaxconn
# K8s Deployment 里调 ulimit
spec:
containers:
- name: server
securityContext:
runAsUser: 1000
resources:
limits:
cpu: "2"
memory: "1Gi"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
accept: too many open files |
ulimit -n 太小 | ulimit -n 100000 或 systemd LimitNOFILE |
| 高并发时连接被拒 | somaxconn 太小 | sysctl -w net.core.somaxconn=4096 |
| 短连接压测后端口耗尽 | TIME_WAIT 太多 | tcp_tw_reuse=1;用长连接 |
面试考法:"支持 10 万连接要调哪些参数""ulimit 与 file-max 区别"。要点:ulimit 进程级、file-max 系统级;somaxconn 全连接队列;tcp_tw_reuse 复用 TIME_WAIT。
5.5 GC 调优实战
为什么需要它:高并发下 GC 停顿会造成 P99 尖刺。调优不是"减少 GC 频率"这么简单,要在 CPU 与内存间权衡。
核心机制:
- GOGC 调大(如 200):GC 频率降,CPU 占用降,但内存涨。
- GOGC 调小(如 50):GC 频率高,内存省,但 CPU 涨。
- GOMEMLIMIT:内存紧张时更积极 GC,防 OOM。
- 大对象分配是 GC 大敌:避免每次请求分配大 slice,用
sync.Pool复用。 - CPU 密集 vs IO 密集:CPU 密集调 GOMAXPROCS;IO 密集调 GC 与连接池。
最小可运行示例:
# 压测时看 GC 停顿
GODEBUG=gctrace=1 ./server
# 输出里 0.05+0.8+0.04 ms:STW 开始 + 并发标记 + STW 结束
# 关注 STW 是否 < 1ms
// sync.Pool 复用临时 buffer
var bufPool = sync.Pool{
New: func() any {
b := make([]byte, 0, 32*1024)
return &b
},
}
func handle(w http.ResponseWriter, r *http.Request) {
bp := bufPool.Get().(*[]byte)
defer bufPool.Put(bp)
// 用 *bp 做临时缓冲
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| P99 偶发尖刺,与 GC 时刻重合 | GC STW | 调 GOGC 减少 GC;用 GOMEMLIMIT 控制内存 |
| 内存持续上涨 | 大对象不回收 | 用 sync.Pool;避免 goroutine 泄漏 |
| CPU 占用高 | GC 频繁 | 调大 GOGC;加内存 |
面试考法:"GC 调优方向""sync.Pool 适合什么""CPU 密集怎么调"。要点:GOGC 权衡 CPU 与内存;Pool 复用临时对象;CPU 密集调 GOMAXPROCS。
5.6 压测方法论与瓶颈定位
为什么需要它:高并发调优必须有数据。压测给出 QPS、P99、错误率、GC 停顿,再用 pprof 定位瓶颈。
核心机制:
- 指标:QPS(每秒请求数)、P50/P95/P99(延迟分位)、错误率、CPU、内存、GC 停顿。
- 工具:
wrk、hey、ghz(gRPC)、k6。 - 阶梯压测:从 100 QPS 开始,每级加 500,观察 P99 何时开始抖。
- 瓶颈定位:CPU profile 看热点;heap profile 看内存;block profile 看阻塞;trace 看时间线。
- 优化后必须再压测,用数据证明提升。
最小可运行示例:
# HTTP 压测
wrk -t4 -c100 -d30s http://127.0.0.1:8080/users
# 输出:
# Requests/sec: 1234.5
# Latency Distribution:
# 50% 12.34ms
# 90% 45.67ms
# 99% 120.00ms
# gRPC 压测
ghz --insecure --proto hello.proto --call HelloService.SayHello \
-d '{"name":"ann"}' -c 100 -n 100000 127.0.0.1:50051
# 压测时抓 profile
go tool pprof http://127.0.0.1:6060/debug/pprof/profile?seconds=30
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 压测结果与生产不符 | 压测模型与生产流量不同 | 按生产读写比例、热点分布压测 |
| P99 高但 P50 正常 | 少量请求慢(GC、锁、慢查询) | 抓 P99 请求的 trace;查慢查询日志 |
| 压测客户端自己成瓶颈 | 并发数不够 | 多台压测机;客户端调 ulimit |
面试考法:"怎么压测""P99 高怎么定位""优化前后怎么对比"。要点:阶梯压测找拐点;P99 高抓 trace;同条件压测对比。
5.7 熔断降级与限流配合
为什么需要它:下游服务挂了,不能让所有请求都等超时。熔断在错误率超阈值时暂时停止调用,降级返回兜底数据。
核心机制:
- 三态:关闭(正常)、打开(停止调用,直接失败)、半开(放少量请求试探)。
- 错误率阈值:如 50% 错误率持续 10 秒,打开。
- 半开恢复:打开 30 秒后放 5 个请求,成功则关闭,失败则继续打开。
- 降级:熔断时返回缓存数据或默认值,而不是 500。
- Go 生态:
sony/gobreaker。
最小可运行示例:
package main
import (
"context"
"errors"
"github.com/sony/gobreaker"
)
var cb = gobreaker.NewCircuitBreaker(gobreaker.Settings{
Name: "order-service",
MaxRequests: 5, // 半开时放 5 个请求
Interval: 10, // 统计窗口 10 秒
Timeout: 30, // 打开 30 秒后半开
ReadyToTrip: func(c gobreaker.Counts) bool {
// 错误率 > 50% 且请求数 > 10 时打开
return c.TotalRequests > 10 &&
float64(c.TotalFailures)/float64(c.TotalRequests) > 0.5
},
})
func callOrder(ctx context.Context) (string, error) {
res, err := cb.Execute(func() (any, error) {
return callOrderService(ctx)
})
if err != nil {
if errors.Is(err, gobreaker.ErrOpenState) {
return "cached-data", nil // 降级返回缓存
}
return "", err
}
return res.(string), nil
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 熔断后一直不放行 | 半开状态没设 | 设 Timeout 与 MaxRequests |
| 熔断返回 500 | 没降级 | 熔断时返回缓存或默认值 |
| 小流量下误熔断 | 请求数太少阈值就触发 | ReadyToTrip 加 TotalRequests > 10 条件 |
面试考法:"熔断三态""为什么要降级""半开作用"。要点:关闭/打开/半开;半开放试探;降级返回兜底。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| semaphore 限并发 | 给批量 DB 调用加 semaphore=20 | 压测下 DB 连接数不超过 20 | 1 小时 |
| 令牌桶限流 | 用 x/time/rate 给接口限流 100 QPS |
超过返回 429 | 1 小时 |
| ulimit 调参 | 调 ulimit -n 100000 |
压测 1 万连接无 too many open files |
1 小时 |
| 阶梯压测 | 用 wrk 从 100 QPS 加到 2000 | 找到 P99 开始抖的拐点 | 2 小时 |
| GC 跟踪 | GODEBUG=gctrace=1 跑压测 |
能说出 STW 时长 | 1 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修复无限并发 | 给定 for 里 go db.Query 代码,加 semaphore |
DB 连接数受控 | 1 小时 |
| 加漏桶 | 给下游调用改用漏桶 | 下游调用速率平滑 | 2 小时 |
| GC 调优 | 给定 P99 尖刺与 GC 重合的服务,调 GOGC | P99 下降,数据对比 | 2 小时 |
| sync.Pool 复用 | 给定每次请求分配大 buffer 的代码,改用 Pool | heap profile 显示分配下降 | 2 小时 |
| 加熔断 | 给下游调用加 gobreaker | 下游故障时快速失败,降级返回 | 2 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 完整压测报告 | 选一个接口,阶梯压测,抓 profile,给优化前后对比 | 数据表格化;有火焰图;根因清晰 | 6 小时 |
| 网关限流层 | 入口令牌桶 + 下游漏桶 + 熔断 | 三层配合;压测下不打垮下游 | 6 小时 |
| 10 万连接服务 | 调内核参数 + 压测 10 万连接 | 无 too many open files;P99 平稳 |
4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
accept: too many open files |
ulimit -n 太小 | ulimit -n;lsof -p <pid> \| wc -l |
ulimit -n 100000 |
| DB 连接池打满 | 无限起 goroutine | 看 DB 连接数;查 semaphore | 用 semaphore 限制并发 ≤ MaxOpenConns |
| P99 偶发尖刺 | GC STW 或锁竞争 | 抓 trace;查 GC 时刻 | 调 GOGC;抓 block profile |
| 压测结果与生产不符 | 压测模型不对 | 对比生产读写比例 | 按生产流量分布压测 |
| 高并发时连接被拒 | somaxconn 太小 | cat /proc/sys/net/core/somaxconn |
sysctl -w net.core.somaxconn=4096 |
| 熔断后一直失败 | 半开没设 | 看 gobreaker 配置 | 设 Timeout 与 MaxRequests |
| 压测客户端成瓶颈 | 并发不够 | 客户端 CPU/网络 | 多台压测机;客户端调 ulimit |
| 短连接压测后端口耗尽 | TIME_WAIT 太多 | ss -s \| grep TIME_WAIT |
tcp_tw_reuse=1;用长连接 |
八、出口条件
全部勾选后,本路径全部阶段完成,回到 路径首页 复习。
- [ ] 能用 semaphore 限制并发 DB 调用,对齐连接池参数
- [ ] 能实现令牌桶限流,说明与漏桶、滑动窗口的取舍
- [ ] 能解释 netpoll 如何基于 epoll 支持高并发连接
- [ ] 能调 ulimit、somaxconn、tcp_tw_reuse 支持 10 万连接
- [ ] 能用 pprof + trace 定位一次 P99 尖刺
- [ ] 能设计压测模型,区分 CPU 密集与 IO 密集的调优方向
- [ ] 能实现熔断三态与降级返回
自测题:
- 为什么不能无限起 goroutine 调 DB?怎么控制?
- 要点:连接池有限;用 semaphore(带缓冲 channel)限制并发 ≤ MaxOpenConns。
- 令牌桶与漏桶的区别?
- 要点:令牌桶允许突发(桶容量),漏桶输出速率恒定;入口用令牌桶,下游调用用漏桶。
- Go 怎么支持 10 万并发连接?
- 要点:每连接一个 goroutine,IO 时 goroutine 挂起不占 M;netpoll 基于 epoll;ulimit 调大。
- P99 高但 P50 正常,怎么定位?
- 要点:少量请求慢;抓 P99 请求的 trace;查慢查询、GC、锁竞争。
- GOGC 调大与调小的代价?
- 要点:调大 GC 频率降但内存涨;调小省内存但 CPU 涨;按容器内存配额权衡。
- 熔断三态是什么?半开的作用?
- 要点:关闭(正常)、打开(停止调用)、半开(放少量请求试探恢复);半开避免故障恢复后立即打满。