mprof.go全程跟拍-跟着一个请求走完四种采集

跟着一个请求,走完 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 已经完整走过一遍:

  1. 进门先看开关 :if blockprofilerate > 0 才按 t0 = cputicks()。开关关着,连秒表都不按,t0 就留在 0。
  2. 挂起前留暗号 :sudog 的 releasetime 先置 0,若 t0 != 0 就改成 -1。这个 -1 不是说"等了负一",是给唤醒方留的一句话------"等你叫醒我时,麻烦补个结束时间"。
  3. 醒来才算账 :唤醒方把 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 不是一堆孤立的函数,它只是把"一次分配、一次等待、一次争用、一次快照"这四件事,各自走完"埋点 → 采样 → 抓栈 → 找桶 → 记账 → 补偿 → 导出"这条同一条路。 你把"我"这一趟记住了,再回头看任何一个函数,都知道它站在路的哪一段。

想回查某个具体函数为什么那样写,翻前面那份《全局串讲》的问题定位表;想顺着走一遍,就照这份跟拍重走一遍。两份合起来,零件和结构就都在了。

相关推荐
tong_li1 小时前
给娃做个 AI 陪写作业助手:LangChain4j 入门(三):配本古诗书(RAG 入门),答得不瞎编
后端
用户48678952533901 小时前
多租户第二集:读隔离做完之后,写路径才是真坑
后端
bai2731 小时前
同一个 1.005,toFixed 给 1.00、Math.round 给 1、Intl 给 1.01:999 个三分位小数的实测
javascript·后端
千寻技术帮1 小时前
基于Spring Boot+Vue的农产品销售管理系统(源码+文档+数据库,附部署教程)
java·数据库·spring boot·后端·mysql·vue
码云社区2 小时前
Spring Boot陪诊陪护系统源码:医院目录、服务项目与城市业务配置
java·spring boot·后端·陪诊陪护·医院陪诊·医院陪护·陪护小程序
码云社区2 小时前
Spring Boot云快充协议源码:充电桩远程重启、参数配置与升级运维方案
运维·spring boot·后端·充电桩·充电系统·充电软件
Csvn2 小时前
Nginx 日志、监控与排障:全字段日志、条件日志与证据链定位
后端·nginx
学长毕设3 小时前
基于SpringBoot 餐饮餐厅点菜管理系统-附源码
java·spring boot·后端
学长毕设4 小时前
基于SpringBoot 校园招聘求职论坛交流系统-附源码
java·spring boot·后端