原文链接：分享如何浏览 Go 语言源码
前言
哈喽，大家好，我是
asong；最近在看 Go 语言调度器相干的源码，发现看源码真是个技术活，所以本文就简略总结一下该如何查看Go源码，心愿对你们有帮忙。
Go 源码包含哪些？
以我集体了解，Go源码次要分为两局部，一部分是官网提供的规范库，一部分是 Go 语言的底层实现，Go语言的所有源码 / 规范库 / 编译器都在 src 目录下：https://github.com/golang/go/…，想看什么库的源码任君抉择；
观看 Go 规范库 and Go底层实现的源代码难易度也是不一样的，咱们个别也能够先从规范库动手，筛选你感兴趣的模块，把它吃透，有了这个根底后，咱们在看 Go 语言底层实现的源代码会略微轻松一些；上面就针对我集体的一点学习心得分享一下如何查看 Go 源码；
查看规范库源代码
规范库的源代码看起来稍容易些，因为规范库也属于下层利用，咱们能够借助 IDE 的帮忙，其在 IDE 上就能够跳转到源代码包，咱们只须要一直来回跳转查看各个函数实现做好笔记即可，因为一些源代码设计的比较复杂，大家在看时最好通过画图辅助一下，集体感觉画 UML 是最有助于了解的，能更清晰的理清各个实体的关系；
有些时候只看代码是很难了解的，这时咱们应用在线调试辅助咱们了解，应用 IDE 提供的调试器或者 GDB 都能够达到目标，写一个简略的 demo，断点一打，单步调试走起来，比方你要查看fmt.Println 的源代码，开局一个小红点，而后就是点点点；
<img src=”https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/020ee5d660264362b42dab2a142bc369~tplv-k3u1fbpfcp-zoom-1.image” />
查看 Go 语言底层实现
人都是会对未知领域充斥好奇，当应用一段时间 Go 语言后，就想更深刻的搞明确一些事件，例如：Go 程序的启动过程是怎么的，goroutine是怎么调度的，map是怎么实现的等等一些 Go 底层的实现，这种间接依附 IDE 跳转追溯代码是办不到的，这些都属于 Go 语言的外部实现，大都在 src 目录下的 runtime 包内实现，其实现了垃圾回收，并发管制，栈治理以及其余一些 Go 语言的要害个性，在编译 Go 代码为机器代码时也会将其也编译进来，runtime就是 Go 程序执行时候应用的库，所以一些 Go 底层原理都在这个包内，咱们须要借助一些形式能力查看到 Go 程序执行时的代码，这里分享两种形式：剖析汇编代码、dlv 调试；
<img src=”https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/43155623d60042d98539d4885bb73020~tplv-k3u1fbpfcp-zoom-1.image” alt=”” />
剖析汇编代码
后面咱们曾经介绍了 Go 语言实现了 runtime 库，咱们想看到一些 Go 语言关键字个性对应 runtime 里的那个函数，能够查看汇编代码，Go语言的汇编应用的 plan9，与x86 汇编差异还是很大，很多敌人都不相熟 plan9 的汇编，然而要想看懂 Go 源码还是要对 plan9 汇编有一个根本的理解的，这里举荐曹大的文章：plan9 assembly 齐全解析，会一点汇编咱们就可以看源代码了，比方想在咱们想看 make 是怎么初始化 slice 的，这时咱们能够先写一个简略的demo：
// main.go
import "fmt"
func main() {s := make([]int, 10, 20)
fmt.Println(s)
}有两种形式能够查看汇编代码：
1. go tool compile -S -N -l main.go
2. go build main.go && go tool objdump ./main形式一是将源代码编译成 .o 文件，并输入汇编代码，形式二是反汇编，这里举荐应用形式一，执行形式一命令后，咱们能够看到对应的汇编代码如下：
<img src=”https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6071b1f1459144f5b891c3c4d60559df~tplv-k3u1fbpfcp-zoom-1.image” />
s := make([]int, 10, 20)对应的源代码就是 runtime.makeslice(SB)，这时候咱们就去runtime 包下找 makeslice 函数，一直追踪上来就可查看源码实现了，可在 runtime/slice.go 中找到：
<img src=”https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d9905faa0ef2479b997279691ddba98f~tplv-k3u1fbpfcp-zoom-1.image” />
在线调试
尽管下面的办法能够帮忙咱们定位到源代码，然而后续的操作全靠 review 还是难于了解的，如果能在线调试跟踪代码能够更好助于咱们了解，目前 Go 语言反对 GDB、LLDB、Delve 调试器，但只有 Delve 是专门为 Go 语言设计开发的调试工具，所以应用 Delve 能够轻松调试 Go 汇编程序，Delve的入门文章有很多，这篇就不在介绍 Delve 的具体应用办法，入门大家能够看曹大的文章：https://chai2010.cn/advanced-…，本文就应用一个小例子带大家来看一看 dlv 如何调试 Go 源码，大家都晓得向一个 nil 的切片追加元素，不会有任何问题，在源码中是怎么实现的呢？接下老咱们应用 dlv 调试跟踪一下，先写一个小demo：
import "fmt"
func main() {var s []int
s = append(s, 1)
fmt.Println(s)
}进入命令行包目录，而后输出 dlv debug 进入调试
$ dlv debug
Type 'help' for list of commands.
(dlv)因为这里咱们想看到 append 的外部实现，所以在 append 那行加上断点，执行如下命令：
(dlv) break main.go:7
Breakpoint 1 set at 0x10aba57 for main.main() ./main.go:7执行 continue 命令，运行到断点处：
(dlv) continue
> main.main() ./main.go:7 (hits goroutine(1):1 total:1) (PC: 0x10aba57)
2:
3: import "fmt"
4:
5: func main() {6: var s []int
=> 7: s = append(s, 1)
8: fmt.Println(s)
9: }接下来咱们执行 disassemble 反汇编命令查看 main 函数对应的汇编代码：
(dlv) disassemble
TEXT main.main(SB) /Users/go/src/asong.cloud/Golang_Dream/code_demo/src_code/main.go
main.go:5 0x10aba20 4c8d6424e8 lea r12, ptr [rsp-0x18]
main.go:5 0x10aba25 4d3b6610 cmp r12, qword ptr [r14+0x10]
main.go:5 0x10aba29 0f86f6000000 jbe 0x10abb25
main.go:5 0x10aba2f 4881ec98000000 sub rsp, 0x98
main.go:5 0x10aba36 4889ac2490000000 mov qword ptr [rsp+0x90], rbp
main.go:5 0x10aba3e 488dac2490000000 lea rbp, ptr [rsp+0x90]
main.go:6 0x10aba46 48c744246000000000 mov qword ptr [rsp+0x60], 0x0
main.go:6 0x10aba4f 440f117c2468 movups xmmword ptr [rsp+0x68], xmm15
main.go:7 0x10aba55 eb00 jmp 0x10aba57
=> main.go:7 0x10aba57* 488d05a2740000 lea rax, ptr [rip+0x74a2]
main.go:7 0x10aba5e 31db xor ebx, ebx
main.go:7 0x10aba60 31c9 xor ecx, ecx
main.go:7 0x10aba62 4889cf mov rdi, rcx
main.go:7 0x10aba65 be01000000 mov esi, 0x1
main.go:7 0x10aba6a e871c3f9ff call $runtime.growslice
main.go:7 0x10aba6f 488d5301 lea rdx, ptr [rbx+0x1]
main.go:7 0x10aba73 eb00 jmp 0x10aba75
main.go:7 0x10aba75 48c70001000000 mov qword ptr [rax], 0x1
main.go:7 0x10aba7c 4889442460 mov qword ptr [rsp+0x60], rax
main.go:7 0x10aba81 4889542468 mov qword ptr [rsp+0x68], rdx
main.go:7 0x10aba86 48894c2470 mov qword ptr [rsp+0x70], rcx
main.go:8 0x10aba8b 440f117c2450 movups xmmword ptr [rsp+0x50], xmm15
main.go:8 0x10aba91 488d542450 lea rdx, ptr [rsp+0x50]
main.go:8 0x10aba96 4889542448 mov qword ptr [rsp+0x48], rdx
main.go:8 0x10aba9b 488b442460 mov rax, qword ptr [rsp+0x60]
main.go:8 0x10abaa0 488b5c2468 mov rbx, qword ptr [rsp+0x68]
main.go:8 0x10abaa5 488b4c2470 mov rcx, qword ptr [rsp+0x70]
main.go:8 0x10abaaa e8f1dff5ff call $runtime.convTslice
main.go:8 0x10abaaf 4889442440 mov qword ptr [rsp+0x40], rax
main.go:8 0x10abab4 488b542448 mov rdx, qword ptr [rsp+0x48]
main.go:8 0x10abab9 8402 test byte ptr [rdx], al
main.go:8 0x10ababb 488d35be640000 lea rsi, ptr [rip+0x64be]
main.go:8 0x10abac2 488932 mov qword ptr [rdx], rsi
main.go:8 0x10abac5 488d7a08 lea rdi, ptr [rdx+0x8]
main.go:8 0x10abac9 833d30540d0000 cmp dword ptr [runtime.writeBarrier], 0x0
main.go:8 0x10abad0 7402 jz 0x10abad4
main.go:8 0x10abad2 eb06 jmp 0x10abada
main.go:8 0x10abad4 48894208 mov qword ptr [rdx+0x8], rax
main.go:8 0x10abad8 eb08 jmp 0x10abae2
main.go:8 0x10abada e8213ffbff call $runtime.gcWriteBarrier
main.go:8 0x10abadf 90 nop
main.go:8 0x10abae0 eb00 jmp 0x10abae2
main.go:8 0x10abae2 488b442448 mov rax, qword ptr [rsp+0x48]
main.go:8 0x10abae7 8400 test byte ptr [rax], al
main.go:8 0x10abae9 eb00 jmp 0x10abaeb
main.go:8 0x10abaeb 4889442478 mov qword ptr [rsp+0x78], rax
main.go:8 0x10abaf0 48c784248000000001000000 mov qword ptr [rsp+0x80], 0x1
main.go:8 0x10abafc 48c784248800000001000000 mov qword ptr [rsp+0x88], 0x1
main.go:8 0x10abb08 bb01000000 mov ebx, 0x1
main.go:8 0x10abb0d 4889d9 mov rcx, rbx
main.go:8 0x10abb10 e8aba8ffff call $fmt.Println
main.go:9 0x10abb15 488bac2490000000 mov rbp, qword ptr [rsp+0x90]
main.go:9 0x10abb1d 4881c498000000 add rsp, 0x98
main.go:9 0x10abb24 c3 ret
main.go:5 0x10abb25 e8f61efbff call $runtime.morestack_noctxt
.:0 0x10abb2a e9f1feffff jmp $main.main从以上内容咱们看到调用了 runtime.growslice 办法，咱们在这里加一个断点：
(dlv) break runtime.growslice
Breakpoint 2 set at 0x1047dea for runtime.growslice() /usr/local/opt/go/libexec/src/runtime/slice.go:162之后咱们再次执行 continue 执行到该断点处：
(dlv) continue
> runtime.growslice() /usr/local/opt/go/libexec/src/runtime/slice.go:162 (hits goroutine(1):1 total:1) (PC: 0x1047dea)
Warning: debugging optimized function
157: // NOT to the new requested capacity.
158: // This is for codegen convenience. The old slice's length is used immediately
159: // to calculate where to write new values during an append.
160: // TODO: When the old backend is gone, reconsider this decision.
161: // The SSA backend might prefer the new length or to return only ptr/cap and save stack space.
=> 162: func growslice(et *_type, old slice, cap int) slice {
163: if raceenabled {164: callerpc := getcallerpc()
165: racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
166: }
167: if msanenabled {之后就是一直的单步调试能够看进去切片的扩容策略；到这里大家也就明确了为啥向 nil 的切片追加数据不会有问题了，因为在容量不够时会调用 growslice 函数进行扩容，具体扩容规定大家能够持续追踪，打脸网上那些瞎写的文章。
上文咱们介绍调试汇编的一个根本流程，上面在介绍两个我在看源代码时常常应用的命令；
- goroutines命令：通过
goroutines命令（简写 grs），咱们能够查看所goroutine，通过goroutine (alias: gr)命令能够查看以后的gourtine：
(dlv) grs
* Goroutine 1 - User: ./main.go:7 main.main (0x10aba6f) (thread 218565)
Goroutine 2 - User: /usr/local/opt/go/libexec/src/runtime/proc.go:367 runtime.gopark (0x1035232) [force gc (idle)]
Goroutine 3 - User: /usr/local/opt/go/libexec/src/runtime/proc.go:367 runtime.gopark (0x1035232) [GC sweep wait]
Goroutine 4 - User: /usr/local/opt/go/libexec/src/runtime/proc.go:367 runtime.gopark (0x1035232) [GC scavenge wait]
Goroutine 5 - User: /usr/local/opt/go/libexec/src/runtime/proc.go:367 runtime.gopark (0x1035232) [finalizer wait]stack命令：通过stack命令（简写 bt），咱们可查看以后函数调用栈信息：
(dlv) bt
0 0x0000000001047e15 in runtime.growslice
at /usr/local/opt/go/libexec/src/runtime/slice.go:183
1 0x00000000010aba6f in main.main
at ./main.go:7
2 0x0000000001034e13 in runtime.main
at /usr/local/opt/go/libexec/src/runtime/proc.go:255
3 0x000000000105f9c1 in runtime.goexit
at /usr/local/opt/go/libexec/src/runtime/asm_amd64.s:1581regs命令：通过regs命令能够查看全副的寄存器状态，能够通过单步执行来察看寄存器的变动：
(dlv) regs
Rip = 0x0000000001047e15
Rsp = 0x000000c00010de68
Rax = 0x00000000010b2f00
Rbx = 0x0000000000000000
Rcx = 0x0000000000000000
Rdx = 0x0000000000000008
Rsi = 0x0000000000000001
Rdi = 0x0000000000000000
Rbp = 0x000000c00010ded0
R8 = 0x0000000000000000
R9 = 0x0000000000000008
R10 = 0x0000000001088c40
R11 = 0x0000000000000246
R12 = 0x000000c00010df60
R13 = 0x0000000000000000
R14 = 0x000000c0000001a0
R15 = 0x00000000000000c8
Rflags = 0x0000000000000202 [IF IOPL=0]
Cs = 0x000000000000002b
Fs = 0x0000000000000000
Gs = 0x0000000000000000locals命令：通过locals命令，能够查看以后函数所有变量值：
(dlv) locals
newcap = 1
doublecap = 0总结
看源代码的过程是没有捷径可走的，如果说有，那就是能够先看一些大佬输入的底层原理的文章，而后参照其文章一步步入门源码浏览，最终还是要本人去克服这个艰难，本文介绍了我本人查看源码的一些形式，你是否有更简便的形式呢？欢送评论区分享进去～。
好啦，本文到这里就完结了，我是asong，咱们下期见。
欢送关注公众号：Golang 梦工厂