跟着一个请求,走完 mprof.go:一次采集的全程跟拍
前面那份《全局串讲》是"汇总"------把零件分门别类摆好,方便回查。这份不一样。
这份是跟拍 :我们挑一个具体的请求,从它诞生那一刻开始,一路跟着它跑。跑到哪一步、这一步从哪个函数进去、怎么被采样、采进哪一种账、最后怎么变成 pprof 里的一行------每一站都当场说清。读完你不用记"有哪些机制",只需记一件事:"我"这个请求,从头到尾经历了什么。
主角是这个再普通不过的处理函数:
go
func handle(req Request) []byte {
buf := make([]byte, 1024) // ① 要一块内存
result := <-downstream // ② 等一个下游结果
mu.Lock() // ③ 抢一把锁改共享缓存
cache[req.ID] = result
mu.Unlock()
return buf
}
就这四行,会把 mprof.go 里几乎每条主干道都踩一遍。
先跑一遍:把主演请上台
光看这四行不过瘾,我们把它补成一份能直接运行的完整程序。存成 main.go,go run main.go 就能跑,跑完会在当前目录生成四份 .prof 文件------正好对应四种采集。
go
package main
import (
"fmt"
"os"
"runtime"
"runtime/pprof"
"sync"
"time"
)
// ========== 起点:打开三只水龙头 ==========
func init() {
runtime.MemProfileRate = 512 // heap:平均每 512 字节采一次(演示调小,生产默认 512KB)
runtime.SetBlockProfileRate(1000) // block:等待超过 1 微秒(1000ns)必采
runtime.SetMutexProfileFraction(1) // mutex:每次锁争用都采(演示设 1,生产可设 5/10)
}
type Request struct{ ID int }
var (
downstream = make(chan []byte) // 模拟下游服务
mu sync.Mutex
cache = make(map[int][]byte)
)
// ========== 跟拍的主角 ==========
func handle(req Request) []byte {
buf := make([]byte, 1024) // ① 要一块内存 → heap 采样
// ② 等一个下游结果 → block 采样(真的阻塞:下游 sleep 后才送)
go func() {
time.Sleep(50 * time.Microsecond)
downstream <- []byte("ok")
}()
result := <-downstream
copy(buf, result)
// ③ 抢锁改共享缓存 → mutex 采样(多 goroutine 同时抢,必然争用)
mu.Lock()
cache[req.ID] = buf
time.Sleep(time.Microsecond) // 故意把临界区拉长一点,制造争用
mu.Unlock()
return buf
}
func dump(name string) {
f, err := os.Create(name + ".prof")
if err != nil {
panic(err)
}
defer f.Close()
if err := pprof.Lookup(name).WriteTo(f, 0); err != nil {
panic(err)
}
}
func main() {
const workers, perWorker = 4, 3000 // 让四种事件都发生足够多次
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < perWorker; i++ {
handle(Request{ID: i})
}
}()
}
wg.Wait()
runtime.GC() // 第 3 站:触发 GC,让销账与三周期翻页发生
// 第 6 站:把四种账翻出来
for _, name := range []string{"heap", "block", "mutex", "goroutine"} {
dump(name)
}
fmt.Println("已生成 heap.prof / block.prof / mutex.prof / goroutine.prof")
}
跑完查看:
bash
go run main.go
go tool pprof -top ./heap.prof # 或 block / mutex / goroutine
实测结果(文中所有数字都来自这一份程序在 go1.24 上的真实输出):
| profile | 排第一的调用 | 说明 |
|---|---|---|
| heap | main.handle 3.12MB(96.93%) |
分配记账抓到了用户函数------callers(5) 跳过 runtime 帧的效果 |
| block | sync.(*Mutex).Lock 13.25s |
等待记在等待方:锁等待 + channel 等待 |
| mutex | sync.(*Mutex).Unlock 16.06s |
等待记在 Unlock 调用者头上------这正是文档第四幕讲的归责语义 |
| goroutine | 1 个(导出时只剩 main) | 全量快照,不采样 |
把这份程序放在手边,下面每讲一站,你都能回到这里找到对应的那行代码。下面开始跟拍。
先看全程地图
这一趟一共八站。前四站是"事件来了被采样",第五、六站是"账本内部怎么翻",后两站是"外人怎么把账翻出来"。
记住这张图。往后每站开头我都会告诉你"我在哪一站",你随时能定位。
起点:谁打开了采样的开关
"我"还没诞生之前,程序启动时得有人先把水龙头调好。mprof.go 里几种采集的开法不一样:heap 默认就开着 (MemProfileRate 初值 512KB),block 和 mutex 默认关着,因为抓栈很贵。
go
runtime.MemProfileRate = 512 * 1024 // heap:直接给全局变量赋值(没有 setter),默认就是这个值
runtime.SetBlockProfileRate(int(1e6)) // block:等待超过 1ms 必采
runtime.SetMutexProfileFraction(5) // mutex:每 5 次争用采 1 次
这三行各自写进三个全局变量:
| 开关 | 写进的变量 | 单位 | 关着时 |
|---|---|---|---|
runtime.MemProfileRate = x(直接赋值,无 setter) |
MemProfileRate |
字节 | 默认 512KB,不是 0;设 0 才关 |
SetBlockProfileRate |
blockprofilerate |
CPU tick(用户给的纳秒会被换算) | 默认 0,关 |
SetMutexProfileFraction |
mutexprofilerate |
次数 | 默认 0,关 |
这里回答"采集什么类型"的第一层 :这三个开关,决定了接下来三种事件会不会被采。第四种 goroutine 不需要开关------它是快照,问一次拍一次。
注意 block/mutex 的用户入参和内部值不是一回事。SetBlockProfileRate 里会把你传的纳秒乘上 ticksPerSecond()/1e9 换成 CPU tick,因为后面 blockevent 拿到的等待时长也是 tick,两者才能直接比大小。这一步就是前面聊过的 ticksPerSecond() 的用武之地。
第 1 站 诞生:go handle(req) 走了哪条路
我在哪 :调度器的 newproc。
一条 go 语句,最终落到 newproc,它给请求造一个新 g,填好入口 handle、参数,塞进运行队列。
这一步看着和 mprof.go 没关系,其实埋了一个伏笔------goroutine profile 的钩子就卡在这里(proc.go:5087):
go
if goroutineProfile.active { // 此刻是否正有人在拍 goroutine 合影
newg.goroutineProfiled.Store(goroutineProfileSatisfied)
// 新造的 g 直接标"已拍过",不进这次快照
}
这一站采不采? 不采。这里只是埋点:新建一个 g 时,如果恰好有人在拍 goroutine profile,就把它标记成"不用拍"(因为快照只要"喊停那一刻"活着的 g)。真正抓这个 g 的栈,要等到第六站。
所以要分清楚两种采集:
- heap / block / mutex 是事件型------事件发生了才采,"我"每触发一次就被考一次;
- goroutine 是快照型------不埋事件,问一次抓一次全量。
采什么类型:这一站为第四种 profile(goroutine)做准备,但没有实际采样动作。
第 2 站 要内存:make 怎么变成 heap 账上的一笔
我在哪 :handle 第一行,make([]byte, 1024)。
从哪个函数进去 :make 落到 mallocgc(分配器),分配器在真正切内存前,先问一句"这次要不要采"。
2.1 第一道门:抽签
这里有个最容易记错的地方:扣字节、判断是否命中的那道闸门,不在 profilealloc 里,而在 mallocgc 的五个分配路径末尾 (malloc.go:1223/1325/1416/1509/1582 扣额度,1225/1327/1418/1511/1584 命中后调用)。每条路径长这样:
go
c.nextSample -= int64(size) // 每笔分配先从额度里扣掉自己的大小
if c.nextSample < 0 || MemProfileRate != c.memProfRate { // 扣成负数,或采样率被改过
profilealloc(mp, x, size) // ← 命中,才进采样函数
}
而 profilealloc(malloc.go:1795)本身极简,只做三件事,不做任何判断 ------记下当前采样率、重抽下一次额度、交给 mProf_Malloc 记账:
go
func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
c := getMCache(mp)
if c == nil {
throw("profilealloc called without a P or outside bootstrapping")
}
c.memProfRate = MemProfileRate // 记下当前采样率,供闸门比对"是否被改过"
c.nextSample = nextSample() // 重抽下一次的额度
mProf_Malloc(mp, x, size) // ← 命中,才去记账
}
这里的关键是 nextSample,也就是你问过的那个"泊松抽签"。它给 rate=0/1 两个极端留了快速路径:
go
func nextSample() int64 {
if MemProfileRate == 0 {
return maxInt64 // 关闭采样:额度设成天文数字,基本永不触发
}
if MemProfileRate == 1 {
return 0 // 每次都采:额度归零,下次分配必中
}
// Plan 9 的 note handler 里不能用浮点,另走 nextSampleNoFP
return int64(fastexprand(MemProfileRate)) // 其余:指数分布抽一个随机间隔
}
怎么采的 :不是"每次分配抛硬币",而是"攒够一段字节数再采一次,这段距离是随机的"。MemProfileRate=512KB 时,平均每分配 512KB 采一次,但间隔用指数分布随机化(fastexprand),避免被周期性分配模式骗过。
c.nextSample -= size 之后 c.nextSample < 0 就是那道门:我的这 1024 字节,多半只是被扣掉的一小段,没命中采样------除非它恰好把额度扣穿。 这正是 heap 采样和 block/mutex 最不一样的地方:它是按字节累积的,不看事件次数。
2.2 命中之后:mProf_Malloc 的五步
假设我这笔刚好命中,进入 mProf_Malloc(mprof.go:437)。它自己不分配内存------x 是 mallocgc 已经分好的。它只做五件事:
① 定页号 :index := (mProfCycle.read()+2)%3。账本分三个周期轮转,先算出这一笔要记到哪一格(往下看 ⑤ 就知道为什么是 +2)。
② 找桶 :stkbucket(memProfile, size, stk, true)。它把整条调用栈算成一个哈希(mprof.go:275),沿哈希链找到"类型相同 + size 相同 + 栈一模一样"的桶,找不到就建一个。所以我这 1024 字节,和另一个请求里同样大小、同样调用路径的 1024 字节,记进同一个桶------profile 里的每一行,就是这样一个桶。
③ 抓栈 :nstk := callers(5, mp.profStack[:])。那个 5 跳过的是 callers 自己、profilealloc、mallocgc 及其变体、makeslice 这些 runtime 内部帧,让栈顶正好落在用户写的 handle 那一行。
④ 贴便签 :setprofilebucket(p, b)(mheap.go:2305)。光在桶里加个数还不够------将来这个对象被 GC 回收时,得知道它对应哪个桶。于是给对象挂一个 specialprofile 便签,用 fixalloc 从非 GC 内存里切出来(避免剖析器自己触发自己)。这就是你追过的 fixalloc/addspecial/specialFindSplicePoint 那一串。
⑤ 落账 :写进 future[index] 这一页(index = (mProfCycle.read()+2)%3,即 C+2,不是当前 cycle、更不是 active)。为什么往未来挪两格?因为 GC 还没跑,现在还不知道这批对象里哪些会活下来;下一轮 GC 释放时记在 C+1,两者正好落在同一物理页碰头,账对齐了才搬进 active。
采什么类型 :heap profile ,账本是 memRecord,字段是 alloc_bytes / allocs;此刻记在 future(暂存页),还没进 active(可导出页)。
第 3 站 GC 来了:我这笔账先销后翻
我在哪:请求还在跑,但后台 GC 启动了。这一站"我"没主动做什么,是 GC 替我把上一站的账处理掉。
3.1 销账:对象死了要减掉
假设 GC 发现我那个 buf 已经没人引用了(请求结束后),清扫 span 时会看到第 2 站贴的那张便签,于是(mheap.go:2376):
go
mProf_Free(sp.b, size) // 找到便签指向的桶
mProf_Free(mprof.go:469)在同一个桶 上把 free_bytes += size、frees++。
这就是 heap 账的特别之处:它同时记分配和释放 。最后导出的"在用量 inuse"是 alloc_bytes - free_bytes。一个对象从生到死,在这本账上留下两条线。
3.2 翻页:三页账本轮转
GC 还有个关键动作(mgc.go:1155、mgc.go:1714):
go
mProf_NextCycle() // 本体只有一行 mProfCycle.increment():周期号 +1,一个字节都不搬
账本长这样(memRecord 里套了三页 future,按 cycle 号取模循环复用):
text
future[(C+2)%3] future[(C+1)%3] future[C%3] active
(分配写这) (释放写这) (最老,待搬) (可导出)
│ │ │ │
└── cycle 每 +1,三个角色往后错一格;真正搬进 active 靠 Flush ──┘
注意别把 NextCycle 想成"搬页":它只把周期号 +1,谁算"最新"、谁算"最老"随之改变(所以索引是取模轮转,不是固定在某一格);真正把账搬进 active 的动作在 Flush。
mProf_NextCycle/mProf_Flush 之间的协调靠 setFlushed(mprof.go:198)------一个 CAS 加位掩码,保证同一时刻只有一个 goroutine 去搬页,别人看到"已经有人在搬了"就跳过。这是你追过的问题七、九。
真正把最老那页并进 active 的是 mProf_FlushLocked(mprof.go:401),而且它对全量桶链 mbuckets 上所有桶都做这件事,不是只搬某一个桶------这是问题十、十二。
采什么类型 :还是 heap 账,但这一站做的是"销账 + 把 future 翻成 active"。到了导出时,memProfileInternal 出料前会自己再调一次 mProf_FlushLocked 把在途的账并进 active,然后只从 active 数数和拷贝 ------future 只是被搬空的暂存页,不作为导出数据源。
第 4 站 等下游:一次阻塞怎么长成 block 账
我在哪 :result := <-downstream,下游还没给数据,"我"要挂起等待。
这一站是 block profile 的完整链路,也是你问得最多的一段。
4.1 埋点:进阻塞前先按秒表
chanrecv 在准备挂起前(chan.go:578-581):
go
var t0 int64
if blockprofilerate > 0 {
t0 = cputicks() // ← 一次 block 事件从这里开始计时
}
mysg.releasetime = 0
if t0 != 0 {
mysg.releasetime = -1 // 打个标记:唤醒我的人,请补个结束时间
}
然后"我"挂到等待队列上睡觉,不占 CPU。
下游写好数据来唤醒我时:
go
if sg.releasetime != 0 {
sg.releasetime = cputicks() // ← 唤醒方补上结束 tick
}
我恢复执行后,算出等待时长,交给 blockevent(接收路径在 chan.go:676;发送路径对称的那份在 chan.go:299):
go
if mysg.releasetime > 0 {
blockevent(mysg.releasetime-t0, 2) // 等了多久
}
这就是"从哪里开始采集"的答案 :不是后台轮询,是 runtime 在明确知道"这里会阻塞"的地方埋点,进阻塞前 cputicks() 按开始、唤醒时补结束。
4.2 闸门:这次等要不要记
blockevent(mprof.go:506)自己不记,先过闸:
go
func blockevent(cycles int64, skip int) {
if cycles <= 0 { cycles = 1 } // 兜底,防除零
rate := int64(atomic.Load64(&blockprofilerate))
if blocksampled(cycles, rate) {
saveblockevent(cycles, rate, skip+1, blockProfile)
}
}
go
func blocksampled(cycles, rate int64) bool {
if rate <= 0 || (rate > cycles && cheaprand64()%rate > cycles) {
return false
}
return true
}
规则一句话:等得久(cycles >= rate)必采;等得短,按 cycles/rate 的概率抽采。回到开头那份程序:门槛设的是 1000ns(1 微秒),而"我"在 channel 上等了 50 微秒,远超门槛,所以这类等待基本必采;只有那些短到不足 1 微秒的等待,才要靠抽签碰运气。
4.3 抓栈:四种姿势选一种
过了闸,进 saveblockevent(mprof.go:533)抓栈。这里有个分岔------你追过的四种抓栈姿势在这里按处境选择:
go
if tracefpunwindoff() || gp.m.hasCgoOnStack() {
// 处境复杂:走通用 unwinder
if gp.m.curg == nil || gp.m.curg == gp {
nstk = callers(skip, mp.profStack) // 抓当前 g,切 g0
} else {
nstk = gcallers(gp.m.curg, skip, mp.profStack) // 抓指定 g 的 saved 栈
}
} else if gp.m.curg == nil || gp.m.curg == gp {
// 没有 cgo、有 frame pointer、抓当前 g:走 fp 快车道
skip -= 1
nstk = fpTracebackPartialExpand(skip, unsafe.Pointer(getfp()), mp.profStack)
} else {
// fp 快车道,但抓的是别人:先用对方 sched.pc 起头,再从 sched.bp 展开
mp.profStack[0] = gp.m.curg.sched.pc
nstk = 1 + fpTracebackPartialExpand(skip, unsafe.Pointer(gp.m.curg.sched.bp), mp.profStack[1:])
}
callers:抓当前 g 的 live 栈,用GetCallerPC/SP拿现场,必须切到g0才能在自己栈上展开自己;gcallers:抓指定 g 的 saved 栈,从gp.sched/syscall出发展开;fpTracebackPartialExpand:沿 frame pointer 链跳,起点getfp()是三行 Plan 9 汇编读 BP 寄存器,遍历本身是纯 Go 两次解引用;- 它们最终都可能落到
unwinder+initAt+tracebackPCs这套通用翻栈流水线上。
这块就是你最后问的那组函数------unwinder 是翻栈游标,initAt 装第一帧,tracebackPCs 驱动循环、展开内联、把 pc+1 写进数组。
4.4 入账:先找桶,再放大
抓完栈进 saveBlockEventStack(mprof.go:859):
go
b := stkbucket(which, 0, stk, true) // block 的 size 传 0
bp := b.bp() // 拿到 blockRecord
if which == blockProfile && cycles < rate {
bp.count += float64(rate) / float64(cycles) // 反向放大
bp.cycles += rate
} else {
bp.count++
bp.cycles += cycles
}
这段不是采样,是采样后的补偿 。短等待是概率抽采,没抽中的事件根本走不到这里;所以每个抽中的样本要乘 1/p = rate/cycles,把丢掉的那些用数学期望补回来。count 记次数、cycles 记总等待时长。
采什么类型 :block profile ,账本是 blockRecord{count, cycles},bucket 类型 blockProfile、size=0。
4.5 铺开地图:runtime 里到底有几处埋点
主角走的是"channel 接收"这一条。但只学这一条,碰到 select、WaitGroup、Cond 的阻塞,你还是会懵------它们到底记不记、记在哪、抓出来的栈顶为什么长不一样?所以这一节把 go1.24 里所有 blockevent 的入口铺开。生产代码一共 五处 (pprof_test.go 里那两处是测试替身,不算)。
先把五处共用的三段式认清楚,其实你在 4.1 已经完整走过一遍:
- 进门先看开关 :
if blockprofilerate > 0才按t0 = cputicks()。开关关着,连秒表都不按,t0就留在 0。 - 挂起前留暗号 :sudog 的
releasetime先置 0,若t0 != 0就改成-1。这个-1不是说"等了负一",是给唤醒方留的一句话------"等你叫醒我时,麻烦补个结束时间"。 - 醒来才算账 :唤醒方把
releasetime写成cputicks()(一个正数);等待者醒来看到releasetime > 0,才拿它减t0得到等待时长,交给blockevent。
五处埋点,逐个认门:
① 阻塞发送:chansend(chan.go:299)
ch <- v 碰上缓冲区满、又没有接收者,就挂到 sendq 上。醒来后 blockevent(mysg.releasetime-t0, 2)。补时间的是 send()(chan.go:347-349),以及关 channel 时的 closechan(chan.go:445-466),两处都是那句 if sg.releasetime != 0 { sg.releasetime = cputicks() }。
② 阻塞接收:chanrecv(chan.go:676)
主角走的这条,<-downstream。代码几乎是发送的复印件:挂 recvq、醒来同样 blockevent(..., 2)。补时间的是 recv()(chan.go:739-741)或 closechan。4.1 贴的就是它。
③ select:selectgo(select.go:535)
select 里所有 case 都没就绪时,selectgo 会把一堆 sudog 同时挂到各 channel 的等待队列上,醒来走的是 retc 这个统一出口:
go
retc:
if caseReleaseTime > 0 {
blockevent(caseReleaseTime-t0, 1) // 注意 skip=1,最小
}
caseReleaseTime 从哪来?selectgo 在确认"是哪个 case 叫醒了我"时,把那个 sudog 的 releasetime 抄过来(select.go:386-388)。而那个 releasetime 仍然是 channel 的 send/recv 补的------所以 select 借的是 channel 的秒表,没有另起一套计时 。t0 则是在 selectgo 开头(select.go:154-157)按的,涵盖的是"从进入 select 到某个 case 就绪"的整段时间。
④ 信号量等待:semacquire1(sema.go:194)
这是覆盖面最广的一处,门下藏着好几种你天天用的 API:
go
if s.releasetime > 0 {
blockevent(s.releasetime-t0, 3+skipframes)
}
sync.Mutex.Lock/sync.RWMutex.RLock/RWMutex.Lock:经sema.go:95/100/105进来,带semaBlockProfile|semaMutexProfile两个标志;sync.WaitGroup.Wait:经sema.go:110进来,只带semaBlockProfile;internal/poll的信号量(sema.go:75,网络 I/O 那类等待),同样带semaBlockProfile。
补时间的是 readyWithTime()(sema.go:123-127),唤醒方 semrelease1 走它把 releasetime 填上。
⑤ 条件变量:notifyListWait(sema.go:599)
对应 sync.Cond.Wait(sync/cond.go:71 调 runtime 的 notifyListWait)。它不走 semacquire1,自己维护一条 notify 链表:
go
goparkunlock(&l.lock, waitReasonSyncCondWait, traceBlockCondWait, 3)
if t0 != 0 {
blockevent(s.releasetime-t0, 2)
}
补时间同样靠 readyWithTime(),由 notifyListNotifyOne(sema.go:644)和 notifyListNotifyAll(sema.go:607)在叫醒等待者时调用。
一张表收口:
| 埋点 | 所在函数 | 你写的 Go 代码 | skip | 谁补的结束时间 |
|---|---|---|---|---|
chan.go:299 |
chansend |
ch <- v(缓冲满 / 无接收者) |
2 | send() / closechan() |
chan.go:676 |
chanrecv |
<-ch(缓冲空 / 无发送者) |
2 | recv() / closechan() |
select.go:535 |
selectgo |
select { case <-a: ... } |
1 | 命中 case 的 channel 补,抄进 caseReleaseTime |
sema.go:194 |
semacquire1 |
Mutex.Lock、RWMutex、WaitGroup.Wait、poll 等待 |
3+skipframes |
readyWithTime() |
sema.go:599 |
notifyListWait |
sync.Cond.Wait |
2 | readyWithTime() |
skip 为什么不一样? blockevent 转给 saveblockevent 时还会 skip+1,所以真正剥掉的是 skip+1 帧。注意:栈顶并不是要落到"你的代码" ------你打开 block profile,最常见的栈顶恰恰是 runtime.chanrecv1、sync.(*Mutex).Lock 这些 runtime 帧。它们就是"阻塞发生在哪"的正确答案。skip 要剥掉的是 blockevent/saveblockevent/callers 这些采样 plumbing,以及埋点到真正阻塞点之间多余的转发层,把"挡在阻塞现场的那扇门"留在栈顶。
我拿一个最小程序实测过(<-ch 加一次 sync.Mutex 争用,SetBlockProfileRate(1)),go tool pprof -raw 打出来的两个样本是:
text
contentions/count delay/nanoseconds
1 30455265: 1 2 3 ← ① runtime.chanrecv1 → ② main.main → ③ runtime.main
1 30401115: 4 3 ← ④ sync.(*Mutex).Lock → ③ runtime.main
栈顶分别是 runtime.chanrecv1 和 sync.(*Mutex).Lock,都不在用户代码里------但门的下一帧就是 main.main,"是谁在等"一眼可见。<-ch 在栈上长成 chanrecv1,那是编译器为单值接收生成的薄包装,内部转调 chanrecv;这也解释了为什么 pprof 里的招牌帧和源码里的埋点函数差着一层。
- channel 埋点直接写在
chansend/chanrecv里,剥掉 plumbing 后栈顶是chanrecv1/chansend1这类薄包装,2层够用; select埋在selectgo出口,离阻塞现场更近,只要1;semacquire1被 sync 包包了好几层:Mutex.Lock→internal/sync.Mutex.Lock→runtime_SemacquireMutex→semacquire1→blockevent。固定跳 3 层会连sync.(*Mutex).Lock也剥掉,于是 sync 那边再传一个skipframes(internal/sync/mutex.go:149传的是2),最终3+2=5,恰好把sync.(*Mutex).Lock留下。RWMutex和WaitGroup传的是0,就只跳 3。
哪些"看着像阻塞"其实不记? 这个边界同样重要:
- 非阻塞收发不会走到埋点------
ch <- v缓冲区有空位、<-ch缓冲区有数据、select带default直接选中,都在挂起前就返回了,压根没按秒表; time.Sleep走的是 timer 路径,runtime/time.go里根本没有blockevent,所以睡眠不计入 block profile;- runtime 内部锁(比如分配时拿
mheap.lock)争用走的是lockTimer,进 mutex 账,不走这里的 block 入口------那是第 5 站 5.2 的事。
一次等待,两本账。 最后提醒一处容易混的:Mutex.Lock 那条路传的是两个标志(sema.go:95),semacquire1 在 sema.go:165-174 用一个 t0 同时喂两边------block 侧靠 releasetime 算等待时长,mutex 侧靠 acquiretime 记同一个起点。所以一次锁争用会在 block 和 mutex 两本账上各留一笔,只是视角不同(谁在等 vs 谁持锁太久)。第 5 站接着讲 mutex。
说到底:入口有五个,尾段只有一条 。不管从哪个门进来,过了各自的闸门,后面都是 4.2 的 blockevent → 4.3 的 saveblockevent → 4.4 的 saveBlockEventStack,一模一样。你要记的不是五套机制,而是五个门牌号加一条走廊。
第 5 站 抢锁:mutex 账和 block 账走同一条尾段
我在哪 :mu.Lock(),但锁被别人占着,"我"要等。
5.1 用户锁:sync.Mutex 走 mutexevent
sync.Mutex.Lock 争不到时,落到 runtime 的 semacquire1 挂起。等持锁的人 Unlock,semrelease1 会算我等了多久(sema.go:251):
go
mutexevent(dt, 3+skipframes)
mutexevent(mprof.go:902)的闸门和 block 不同:
go
rate := int64(atomic.Load64(&mutexprofilerate))
if rate > 0 && cheaprand64()%rate == 0 {
saveblockevent(cycles, rate, skip+1, mutexProfile)
}
它不看等了多久,纯粹每 rate 次争用抽 1 次 。抽中之后,后面抓栈、找桶、入账全和第 4 站共用同一套 ------这就是 saveblockevent 那个 which 参数的用处:同一个函数,传 blockProfile 就记 block 账,传 mutexProfile 就记 mutex 账。
补偿公式也跟着变(mutex 的抽中概率恒为 1/rate):
go
bp.count += float64(rate) // 一个样本代表 rate 次真实争用
bp.cycles += rate * cycles
5.2 runtime 自己的锁:另一条 lockTimer 支路
如果"我"在 runtime 内部(比如 make 触发的分配拿 mheap.lock),走的不是 mutexevent,而是 lockTimer------你追过的那条:
go
timer := &lockTimer{lock: l}
timer.begin() // 抢锁失败,按秒表
...
timer.end() // 抢到了,算时长
它存在的理由是:抢锁失败的那一刻,M 手里正攥着别的锁,不能分配、不能加锁、不能抓栈,只能用栈上的秒表先盖个时间戳;等解到最后一把锁、两手空空了,才把"时长 + 解锁点调用栈"交进 mutex profile(saveBlockEventStack(..., mutexProfile))。源码写的条件是 recordUnlock 里判断 m.locks == 1------注意此时 unlock2 还没执行 m.locks--,所以 ==1 正是"这是最后一把锁、减完就归零"的意思。
关键点 :runtime 内部锁的账和用户 sync.Mutex 的账,最后汇进同一个 mutex profile 桶。所以你在 pprof 里看到的那一行,两种锁争用是混在一起的。
采什么类型 :mutex profile ,账本还是 blockRecord,但 bucket 类型 mutexProfile、size=0。
第 6 站 有人查账:四种账怎么被翻出来
我在哪:请求处理完了。有人在另一个 goroutine 里调用:
go
pprof.Lookup("heap").WriteTo(w, 0)
pprof.Lookup("block").WriteTo(w, 0)
pprof.Lookup("mutex").WriteTo(w, 0)
runtime.GoroutineProfile(records)
这一站不再采样,而是把前面记的账翻出来。前三种 profile 走两段式协议 ,第四种走并发合影协议。
6.1 heap / block / mutex:同一把"两段式尺子"
三种账的导出共用一套"两段式"骨架,各自的实现分别是 memProfileInternal(heap)、blockProfileInternal(block)、mutexProfileInternal(mutex)。先看这套骨架长什么样:
go
// 第一次:size = len(p) = 0,只数不拷
n = 数一遍 mbuckets,inuse 非零的桶数
if n > size { // 0 个位置的切片装不下 n 条 → 一条都不拷
return n, false // 把"需要几条"告诉调用方
}
// 调用方按 n 裁切片:p = make([]Record, n+50)
// 第二次:size = n+50,真拷
if n <= size { // 这次装得下了
for 每个桶 {
copyFn(记录) // 这时才真正写进 p
}
return n, true
}
这就是你问过的 n/size :size 是调用方切片能装几条,n 是实际要写几条,单位都是"条",不是字节 。一个桶对应一条记录,所以每数到一个符合条件的桶就 n++。那个 +50 是防止两次调用之间又有新桶冒出来、切片不够装导致 ok=false 重来。
再追问一句:这三个 Internal,到底是哪三个函数?又是在哪儿被调的?
先纠一个特别容易踩的坑------并不是"三种账都导出 memProfileInternal"。恰恰相反,三者各有各的真实现,只是两段式的骨架长得一模一样,才容易被笼统说成"都走 memProfileInternal"。真要抠名字,得拆成三层看:
第一层,pprof 包侧的三行声明 (pprof.go:983/986/989)。它们只是三个函数签名,靠 //go:linkname 硬绑到 runtime 的同名符号上:
go
//go:linkname pprof_memProfileInternal runtime.pprof_memProfileInternal
//go:linkname pprof_blockProfileInternal runtime.pprof_blockProfileInternal
//go:linkname pprof_mutexProfileInternal runtime.pprof_mutexProfileInternal
第二层,runtime 侧的三个桥接函数 (mprof.go:1096/1214/1265)。名字一一对应,干的活也一模一样:把切片 p 折成 len(p) 交给真实现,再用一个闭包 p[0]=r; p=p[1:] 把记录往调用方的切片里填:
| 桥接函数(runtime 侧) | 真实现 | 真实现位置 |
|---|---|---|
pprof_memProfileInternal(mprof.go:1096) |
memProfileInternal |
mprof.go:1017 |
pprof_blockProfileInternal(mprof.go:1214) |
blockProfileInternal |
mprof.go:1163 |
pprof_mutexProfileInternal(mprof.go:1265) |
mutexProfileInternal |
mprof.go:1242 |
第三层 ,就是表里那三个真实现------它们才是各写各的 n/ok 两段式逻辑。
那么在哪儿调用? 分两条路:
- heap 单独走 :
writeHeapInternal(pprof.go:602)在自己函数体里调了两次pprof_memProfileInternal------619行传nil只数数,625行传裁好的p真拷。之所以不假手他人,是因为 heap 记录是MemProfileRecord,还要按debug排序(637行)、按MemProfileRate折算比例(634行),杂活多,值得单开一个函数。 - block / mutex 共用一个中间人 :
writeBlock(pprof.go:917)和writeMutex(pprof.go:922)自己不取数,只在918/923行把pprof_blockProfileInternal/pprof_mutexProfileInternal当函数指针 塞给writeProfileInternal(pprof.go:927)。两段式的那两次调用,统一发生在writeProfileInternal内部的929(传nil数数)和932(传p真拷)。这正好呼应第 5 站说的:mutex 和 block"走同一条尾段"------连导出层都是同一个函数,只把"翻哪本账"换掉。
一句话收口:名字上是三个 Internal,实现上是三份,但调用处只有两个------heap 一处,block/mutex 共用一处。
6.2 goroutine:两次 STW 夹一段"世界照跑"
runtime.GoroutineProfile 走 goroutineProfileWithLabelsConcurrent(mprof.go:1369),套路完全不同。你不能把全世界停住慢慢抓------太贵。它的做法是:
第一站埋的那个钩子在这里生效:世界恢复后,调度器在每个 g 即将开始运行的地方检查 goroutineProfile.active------execute、exitsyscall、newproc1,以及 coroutine 切换时的 coroswitch_m(go1.24 一共四处),让每个 g 在"自己被调度到、栈还没被改动"的那一刻把自己的栈登记进白板。协调者再用 forEachGRace 把那些睡着的、没机会被调度的 g 补上。
每个 g 的栈由 saveg(mprof.go:1670)抓:
go
var u unwinder
u.initAt(pc, sp, 0, gp, unwindSilentErrors) // 定起点
n := tracebackPCs(&u, 0, pcbuf) // 全量翻栈到草稿纸
r.Stack = make([]uintptr, n) // 按实际长度精确分配
copy(r.Stack, pcbuf)
pcbuf 是专用草稿纸,不跟 mp.profStack 共用------否则 make(r.Stack) 这一下要是触发了分配采样,就把刚抓的栈覆盖了。这也是你问过的一问。
抓完之后白板被清空:active=false、records=nil、三态复位成 Absent。三个原因:恢复"没人在拍照"的不变量(否则调度器每次都白检查,性能灾难)、撒手调用方的切片(防内存泄漏)、offset.Swap(0) 归零写指针并为一致性校验取出 endOffset。
采什么类型 :goroutine profile------这一站只是导出,但导出的正是第 1 站埋点、这一刻抓下的全量快照。它是唯一不采样的 profile。
终点:火焰图上,我这四行变成什么
四站采集 + 两站翻转,最后在 pprof 里落成了四份记录。我的那四行代码,分别出现在这几份里:
| 代码 | 落在哪份 profile | 账本 | 采不采、怎么采 |
|---|---|---|---|
buf := make([]byte,1024) |
heap | memRecord |
按字节泊松抽采,记在 future 再翻 active |
result := <-downstream |
block | blockRecord |
事件驱动,等太久/抽中才记,短等待反向放大 |
mu.Lock() |
mutex | blockRecord |
每 rate 次争用抽 1 次,反向放大 |
go handle(req)(这个 g 自己) |
goroutine | StackRecord |
不采样,两次 STW 之间的全量快照 |
四种账,两套账本结构(memRecord 和 blockRecord),一个共同的找桶函数 stkbucket,一个共同的导出思想("先数数、再拷贝"的两段式)。这就是 mprof.go 的全部骨架。
五种 profile 的补偿方式也在这里收口(你问过"是不是只有阻塞和锁这样采"):
- block/mutex:写入时 按
1/p放大; - heap:写入时不放大,导出时 用
scaleHeapSample按泊松模型放大; - cpu:靠
SIGPROF定时信号,样本数乘周期估时间,不放大; - goroutine:全量快照,根本不采样。
一路走来,每种采集的"身份卡"
跟完这一趟,如果用一张表把四种采集的"从哪开始、到哪去"钉住,就是这个样子。它是全程的速查,不是新的知识点:
| 采集 | 从哪开始 | 闸门在哪 | 抓栈走哪条 | 账本 | 补偿时机 |
|-----------|--------------------------------------------------------|-----------------------------|---------------------------------|-------------------|---------------------------|-------------|-----------------------|
| heap | mallocgc 五条路径末尾按字节扣 nextSample,扣穿才进 profilealloc | `c.nextSample<0 | | rate变了` 才采(在调用方) | callers(5)(跳 runtime 帧) | memRecord | 导出时 scaleHeapSample |
| block | 进阻塞前 t0=cputicks(),唤醒写 releasetime | blockevent → blocksampled | callers/gcallers/fp 快展/unwinder | blockRecord | 写入时 rate/cycles |
| mutex | 锁争用唤醒 mutexevent / runtime 锁 lockTimer | cheaprand64()%rate==0 | 同上;runtime 锁延后到 unlock | blockRecord | 写入时 rate |
| goroutine | GoroutineProfile 调用那一刻 | 无(全量) | saveg → unwinder | StackRecord | 无 |
写在最后
回头看这一趟:"我"这个请求,从 go handle(req) 诞生,被 make 采了一次堆、被 channel 阻塞采了一次 block、被 mu.Lock 采了一次 mutex,中间的 GC 把堆账销掉并翻页,最后有人调 pprof,把四种账一起翻出来,画成了火焰图上的几行。
mprof.go 不是一堆孤立的函数,它只是把"一次分配、一次等待、一次争用、一次快照"这四件事,各自走完"埋点 → 采样 → 抓栈 → 找桶 → 记账 → 补偿 → 导出"这条同一条路。 你把"我"这一趟记住了,再回头看任何一个函数,都知道它站在路的哪一段。
想回查某个具体函数为什么那样写,翻前面那份《全局串讲》的问题定位表;想顺着走一遍,就照这份跟拍重走一遍。两份合起来,零件和结构就都在了。