罗罗编程学习记录
本页内容 展开查看

05.9 阶段 8 高并发进阶(可选,面向中高级岗位)

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

这是整条路径的最后一个阶段,面向中高级岗位与"要做网关/消息中间件/高并发服务"的人。前七个阶段解决"怎么写一个正确的服务",本阶段解决"怎么在单机 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 密集的调优方向
  • [ ] 能实现熔断三态与降级返回

自测题:

  1. 为什么不能无限起 goroutine 调 DB?怎么控制?
    • 要点:连接池有限;用 semaphore(带缓冲 channel)限制并发 ≤ MaxOpenConns。
  2. 令牌桶与漏桶的区别?
    • 要点:令牌桶允许突发(桶容量),漏桶输出速率恒定;入口用令牌桶,下游调用用漏桶。
  3. Go 怎么支持 10 万并发连接?
    • 要点:每连接一个 goroutine,IO 时 goroutine 挂起不占 M;netpoll 基于 epoll;ulimit 调大。
  4. P99 高但 P50 正常,怎么定位?
    • 要点:少量请求慢;抓 P99 请求的 trace;查慢查询、GC、锁竞争。
  5. GOGC 调大与调小的代价?
    • 要点:调大 GC 频率降但内存涨;调小省内存但 CPU 涨;按容器内存配额权衡。
  6. 熔断三态是什么?半开的作用?
    • 要点:关闭(正常)、打开(停止调用)、半开(放少量请求试探恢复);半开避免故障恢复后立即打满。