关于golang:个人经验分享如何阅读Go语言源码

原文链接：分享如何浏览 Go 语言源码

哈喽，大家好，我是 asong；最近在看 Go 语言调度器相干的源码，发现看源码真是个技术活，所以本文就简略总结一下该如何查看Go 源码，心愿对你们有帮忙。

以我集体了解，Go源码次要分为两局部，一部分是官网提供的规范库，一部分是 Go 语言的底层实现，Go语言的所有源码 / 规范库 / 编译器都在 src 目录下：https://github.com/golang/go/…，想看什么库的源码任君抉择；

观看 Go 规范库 and Go底层实现的源代码难易度也是不一样的，咱们个别也能够先从规范库动手，筛选你感兴趣的模块，把它吃透，有了这个根底后，咱们在看 Go 语言底层实现的源代码会略微轻松一些；上面就针对我集体的一点学习心得分享一下如何查看 Go 源码；

规范库的源代码看起来稍容易些，因为规范库也属于下层利用，咱们能够借助 IDE 的帮忙，其在 IDE 上就能够跳转到源代码包，咱们只须要一直来回跳转查看各个函数实现做好笔记即可，因为一些源代码设计的比较复杂，大家在看时最好通过画图辅助一下，集体感觉画 UML 是最有助于了解的，能更清晰的理清各个实体的关系；

有些时候只看代码是很难了解的，这时咱们应用在线调试辅助咱们了解，应用 IDE 提供的调试器或者 GDB 都能够达到目标，写一个简略的 demo，断点一打，单步调试走起来，比方你要查看fmt.Println 的源代码，开局一个小红点，而后就是点点点；

人都是会对未知领域充斥好奇，当应用一段时间 Go 语言后，就想更深刻的搞明确一些事件，例如：Go 程序的启动过程是怎么的，goroutine是怎么调度的，map是怎么实现的等等一些 Go 底层的实现，这种间接依附 IDE 跳转追溯代码是办不到的，这些都属于 Go 语言的外部实现，大都在 src 目录下的 runtime 包内实现，其实现了垃圾回收，并发管制，栈治理以及其余一些 Go 语言的要害个性，在编译 Go 代码为机器代码时也会将其也编译进来，runtime就是 Go 程序执行时候应用的库，所以一些 Go 底层原理都在这个包内，咱们须要借助一些形式能力查看到 Go 程序执行时的代码，这里分享两种形式：剖析汇编代码、dlv 调试；

后面咱们曾经介绍了 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 文件，并输入汇编代码，形式二是反汇编，这里举荐应用形式一，执行形式一命令后，咱们能够看到对应的汇编代码如下：

s := make([]int, 10, 20)对应的源代码就是 runtime.makeslice(SB)，这时候咱们就去runtime 包下找 makeslice 函数，一直追踪上来就可查看源码实现了，可在 runtime/slice.go 中找到：

尽管下面的办法能够帮忙咱们定位到源代码，然而后续的操作全靠 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:1581

regs命令：通过 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 = 0x0000000000000000

locals命令：通过 locals 命令，能够查看以后函数所有变量值：

(dlv) locals
newcap = 1
doublecap = 0

看源代码的过程是没有捷径可走的，如果说有，那就是能够先看一些大佬输入的底层原理的文章，而后参照其文章一步步入门源码浏览，最终还是要本人去克服这个艰难，本文介绍了我本人查看源码的一些形式，你是否有更简便的形式呢？欢送评论区分享进去～。

好啦，本文到这里就完结了，我是asong，咱们下期见。

欢送关注公众号：Golang 梦工厂

关于golang:个人经验分享如何阅读Go语言源码

前言

Go 源码包含哪些？

查看规范库源代码

查看 Go 语言底层实现

剖析汇编代码

在线调试

总结

Just My Socks（注册教程内含优惠码）

关于golang:个人经验分享如何阅读Go语言源码

前言

Go 源码包含哪些？

查看规范库源代码

查看 Go 语言底层实现

剖析汇编代码

在线调试

总结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）