10.13 萬字長文詳解 Go 程序是怎樣跑起來的？

作者 | qcrao

出品 | CSDN博客

剛開始寫這篇文章的時候，目標非常大，想要探索 Go 程序的一生：編碼、編譯、彙編、鏈接、運行、退出。它的每一步具體如何進行，力圖弄清 Go 程序的這一生。

在這個過程中，我又複習了一遍《程序員的自我修養》。這是一本講編譯、鏈接的書，非常詳細，值得一看！數年前，我第一次看到這本書的書名，就非常喜歡。因為它模仿了周星馳喜劇之王裡出現的一本書 ——《演員的自我修養》。心嚮往之！

在開始本文之前，先推薦一位頭條大佬的博客——《面向信仰編程》，他的 Go 編譯系列文章，非常有深度，直接深入編譯器源代碼，我是看了很多遍了。博客鏈接可以從參考資料裡獲取。

理想很大，實現的難度也是非常大。為了避免砸了“深度解密”這個牌子，這次起了個更溫和的名字。

下面是文章的目錄：

引入

我們從一個 HelloWorld 的例子開始：

<code>package main 
import "fmt"
funcmain{
fmt.Println("hello world")
}/<code>

當我用我那價值 1800 元的 cherry 鍵盤瀟灑地敲完上面的 hello world 代碼時，保存在硬盤上的 hello.go 文件就是一個字節序列了，每個字節代表一個字符。

用 vim 打開 hello.go 文件，在命令行模式下，輸入命令：

<code>:%!xxd/<code>

就能在 vim 裡以十六進制查看文件內容：

最左邊的一列代表地址值，中間一列代表文本對應的 ASCII 字符，最右邊的列就是我們的代碼。再在終端裡執行 man ascii：

和 ASCII 字符表一對比，就能發現，中間的列和最右邊的列是一一對應的。也就是說，剛剛寫完的 hello.go 文件都是由 ASCII 字符表示的，它被稱為 文本文件，其他文件被稱為 二進制文件。

當然，更深入地看，計算機中的所有數據，像磁盤文件、網絡中的數據其實都是一串比特位組成，取決於如何看待它。在不同的情景下，一個相同的字節序列可能表示成一個整數、浮點數、字符串或者是機器指令。

而像 hello.go 這個文件，8 個 bit，也就是一個字節看成一個單位（假定源程序的字符都是 ASCII 碼），最終解釋成人類能讀懂的 Go 源碼。

Go 程序並不能直接運行，每條 Go 語句必須轉化為一系列的低級機器語言指令，將這些指令打包到一起，並以二進制磁盤文件的形式存儲起來，也就是可執行目標文件。

從源文件到可執行目標文件的轉化過程：

完成以上各個階段的就是 Go 編譯系統。你肯定知道大名鼎鼎的 GCC（GNU Compile Collection），中文名為 GNU 編譯器套裝，它支持像 C，C++，Java，Python，Objective-C，Ada，Fortran，Pascal，能夠為很多不同的機器生成機器碼。

可執行目標文件可以直接在機器上執行。一般而言，先執行一些初始化的工作；找到 main 函數的入口，執行用戶寫的代碼；執行完成後，main 函數退出；再執行一些收尾的工作，整個過程完畢。

在接下來的文章裡，我們將探索 編譯和 運行的過程。

編譯鏈接概述

Go 源碼裡的編譯器源碼位於 src/cmd/compile 路徑下，鏈接器源碼位於 src/cmd/link 路徑下。

編譯過程

我比較喜歡用 IDE（集成開發環境）來寫代碼， Go 源碼用的 Goland，有時候直接點擊 IDE 菜單欄裡的“運行”按鈕，程序就跑起來了。這實際上隱含了編譯和鏈接的過程，我們通常將編譯和鏈接合併到一起的過程稱為構建（Build）。

編譯過程就是對源文件進行詞法分析、語法分析、語義分析、優化，最後生成彙編代碼文件，以 .s 作為文件後綴。

之後，彙編器會將彙編代碼轉變成機器可以執行的指令。由於每一條彙編語句幾乎都與一條機器指令相對應，所以只是一個簡單的一一對應，比較簡單，沒有語法、語義分析，也沒有優化這些步驟。

編譯器是將高級語言翻譯成機器語言的一個工具，編譯過程一般分為 6 步：掃描、語法分析、語義分析、源代碼優化、代碼生成、目標代碼優化。下圖來自《程序員的自我修養》：

詞法分析

通過前面的例子，我們知道，Go 程序文件在機器看來不過是一堆二進制位。我們能讀懂，是因為 Goland 按照 ASCII 碼（實際上是 UTF-8）把這堆二進制位進行了編碼。例如，把 8個 bit 位分成一組，對應一個字符，通過對照 ASCII 碼錶就可以查出來。

當把所有的二進制位都對應成了 ASCII 碼字符後，我們就能看到有意義的字符串。它可能是關鍵字，例如：package；可能是字符串，例如：“Hello World”。

詞法分析其實幹的就是這個。輸入是原始的 Go 程序文件，在詞法分析器看來，就是一堆二進制位，根本不知道是什麼東西，經過它的分析後，變成有意義的記號。簡單來說，詞法分析是計算機科學中將字符序列轉換為標記（token）序列的過程。

我們來看一下維基百科上給出的定義：

詞法分析（lexical analysis）是計算機科學中將字符序列轉換為標記（token）序列的過程。進行詞法分析的程序或者函數叫作詞法分析器（lexical analyzer，簡稱lexer），也叫掃描器（scanner）。詞法分析器一般以函數的形式存在，供語法分析器調用。

.go 文件被輸入到掃描器（Scanner），它使用一種類似於 有限狀態機的算法，將源代碼的字符系列分割成一系列的記號（Token）。

記號一般分為這幾類：關鍵字、標識符、字面量（包含數字、字符串）、特殊符號（如加號、等號）。

例如，對於如下的代碼：

<code>slice[i] = i * (2 + 6)/<code>

總共包含 16 個非空字符，經過掃描後：

上面的例子源自《程序員的自我修養》，主要講解編譯、鏈接相關的內容，很精彩，推薦研讀。

Go 語言（本文的 Go 版本是 1.9.2）掃描器支持的 Token 在源碼中的路徑：

<code>src/cmd/compile/internal/syntax/token.go
/<code>

感受一下：

<code>var tokstrings = [...]string{ 
// source control
_EOF: "EOF",
// names and literals
_Name: "name",
_Literal: "literal",
// operators and operations
_Operator: "op",
_AssignOp: "op=",
_IncOp: "opop",
_Assign: "=",
_Define: ":=",
_Arrow: "<-",
_Star: "*",
// delimitors
_Lparen: "(",
_Lbrack: "[",
_Lbrace: "{",
_Rparen: ")",
_Rbrack: "]",
_Rbrace: "}",
_Comma: ",",
_Semi: ";",
_Colon: ":",
_Dot: ".",
_DotDotDot: "...",
// keywords
_Break: "break", 

_Case: "case",
_Chan: "chan",
_Const: "const",
_Continue: "continue",
_Default: "default",
_Defer: "defer",
_Else: "else",
_Fallthrough: "fallthrough",
_For: "for",
_Func: "func",
_Go: "go",
_Goto: "goto",
_If: "if",
_Import: "import",
_Interface: "interface",
_Map: "map",
_Package: "package",
_Range: "range",
_Return: "return",
_Select: "select",
_Struct: "struct",
_Switch: "switch",
_Type: "type",
_Var: "var",
}/<code>

還是比較熟悉的，包括名稱和字面量、操作符、分隔符和關鍵字。

而掃描器的路徑是：

<code>src/cmd/compile/internal/syntax/scanner.go
/<code>

其中最關鍵的函數就是 next 函數，它不斷地讀取下一個字符（不是下一個字節，因為 Go 語言支持 Unicode 編碼，並不是像我們前面舉得 ASCII 碼的例子，一個字符只有一個字節），直到這些字符可以構成一個 Token。

<code>func (s *scanner) next{ 

// ……
redo:
// skip white space
c := s.getr
for c == ' ' || c == '\\t' || c == '\\n' && !nlsemi || c == '\\r' {
c = s.getr
}
// token start
s.line, s.col = s.source.line0, s.source.col0
if isLetter(c) || c >= utf8.RuneSelf && s.isIdentRune(c, true) {
s.ident
return
}
switch c {
// ……
case '\\n':
s.lit = "newline"
s.tok = _Semi
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
s.number(c)
// ……
default:
s.tok = 0
s.error(fmt.Sprintf("invalid character %#U", c))
goto redo
return
assignop:
if c == '=' {
s.tok = _AssignOp
return
}
s.ungetr
s.tok = _Operator
}/<code>

代碼的主要邏輯就是通過 c:=s.getr 獲取下一個未被解析的字符，並且會跳過之後的空格、回車、換行、tab 字符，然後進入一個大的 switch-case 語句，匹配各種不同的情形，最終可以解析出一個 Token，並且把相關的行、列數字記錄下來，這樣就完成一次解析過程。

當前包中的詞法分析器 scanner 也只是為上層提供了 next 方法，詞法解析的過程都是惰性的，只有在上層的解析器需要時才會調用 next 獲取最新的 Token。

語法分析

上一步生成的 Token 序列，需要經過進一步處理，生成一棵以 表達式為結點的 語法樹。

比如最開始的那個例子， slice[i]=i*(2+6)，得到的一棵語法樹如下：

整個語句被看作是一個賦值表達式，左子樹是一個數組表達式，右子樹是一個乘法表達式；數組表達式由 2 個符號表達式組成；乘號表達式則是由一個符號表達式和一個加號表達式組成；加號表達式則是由兩個數字組成。符號和數字是最小的表達式，它們不能再被分解，通常作為樹的葉子節點。

語法分析的過程可以檢測一些形式上的錯誤，例如：括號是否缺少一半， + 號表達式缺少一個操作數等。

語法分析是根據某種特定的形式文法（Grammar）對 Token 序列構成的輸入文本進行分析並確定其語法結構的一種過程。

語義分析

語法分析完成後，我們並不知道語句的具體意義是什麼。像上面的 * 號的兩棵子樹如果是兩個指針，這是不合法的，但語法分析檢測不出來，語義分析就是幹這個事。

編譯期所能檢查的是靜態語義，可以認為這是在“代碼”階段，包括變量類型的匹配、轉換等。例如，將一個浮點值賦給一個指針變量的時候，明顯的類型不匹配，就會報編譯錯誤。而對於運行期間才會出現的錯誤：不小心除了一個 0 ，語義分析是沒辦法檢測的。

語義分析階段完成之後，會在每個節點上標註上類型：

Go 語言編譯器在這一階段檢查常量、類型、函數聲明以及變量賦值語句的類型，然後檢查哈希中鍵的類型。實現類型檢查的函數通常都是幾千行的巨型 switch/case 語句。

類型檢查是 Go 語言編譯的第二個階段，在詞法和語法分析之後我們得到了每個文件對應的抽象語法樹，隨後的類型檢查會遍歷抽象語法樹中的節點，對每個節點的類型進行檢驗，找出其中存在的語法錯誤。

在這個過程中也可能會對抽象語法樹進行改寫，這不僅能夠去除一些不會被執行的代碼對編譯進行優化提高執行效率，而且也會修改 make、new 等關鍵字對應節點的操作類型。

例如比較常用的 make 關鍵字，用它可以創建各種類型，如 slice，map，channel 等等。到這一步的時候，對於 make 關鍵字，也就是 OMAKE 節點，會先檢查它的參數類型，根據類型的不同，進入相應的分支。如果參數類型是 slice，就會進入 TSLICE case 分支，檢查 len 和 cap 是否滿足要求，如 len <= cap。最後節點類型會從 OMAKE 改成 OMAKESLICE。

中間代碼生成

我們知道，編譯過程一般可以分為前端和後端，前端生成和平臺無關的中間代碼，後端會針對不同的平臺，生成不同的機器碼。

前面詞法分析、語法分析、語義分析等都屬於編譯器前端，之後的階段屬於編譯器後端。

編譯過程有很多優化的環節，在這個環節是指源代碼級別的優化。它將語法樹轉換成中間代碼，它是語法樹的順序表示。

中間代碼一般和目標機器以及運行時環境無關，它有幾種常見的形式：三地址碼、P-代碼。例如，最基本的 三地址碼是這樣的：

<code>x = y op z
/<code>

表示變量 y 和 變量 z 進行 op 操作後，賦值給 x。op 可以是數學運算，例如加減乘除。

前面我們舉的例子可以寫成如下的形式：

<code>t1 = 2 + 6 
t2 = i * t1
slice[i] = t2/<code>

這裡 2 + 6 是可以直接計算出來的，這樣就把 t1 這個臨時變量“優化”掉了，而且 t1 變量可以重複利用，因此 t2 也可以“優化”掉。優化之後：

<code>t1 = i * 8 
slice[i] = t1/<code>

Go 語言的中間代碼表示形式為 SSA（Static Single-Assignment，靜態單賦值），之所以稱之為單賦值，是因為每個名字在 SSA 中僅被賦值一次。

這一階段會根據 CPU 的架構設置相應的用於生成中間代碼的變量，例如編譯器使用的指針和寄存器的大小、可用寄存器列表等。中間代碼生成和機器碼生成這兩部分會共享相同的設置。

在生成中間代碼之前，會對抽象語法樹中節點的一些元素進行替換。這裡引用《面向信仰編程》編譯原理相關博客裡的一張圖：

例如對於 map 的操作 m[i]，在這裡會被轉換成 mapacess 或 mapassign。

Go 語言的主程序在執行時會調用 runtime 中的函數，也就是說關鍵字和內置函數的功能其實是由語言的編譯器和運行時共同完成的。

中間代碼的生成過程其實就是從 AST 抽象語法樹到 SSA 中間代碼的轉換過程，在這期間會對語法樹中的關鍵字在進行一次更新，更新後的語法樹會經過多輪處理轉變最後的 SSA 中間代碼。

目標代碼生成與優化

不同機器的機器字長、寄存器等等都不一樣，意味著在不同機器上跑的機器碼是不一樣的。最後一步的目的就是要生成能在不同 CPU 架構上運行的代碼。

為了榨乾機器的每一滴油水，目標代碼優化器會對一些指令進行優化，例如使用移位指令代替乘法指令等。

這塊實在沒能力深入，幸好也不需要深入。對於應用層的軟件開發工程師來說，瞭解一下就可以了。

鏈接過程

編譯過程是針對單個文件進行的，文件與文件之間不可避免地要引用定義在其他模塊的全局變量或者函數，這些變量或函數的地址只有在此階段才能確定。

鏈接過程就是要把編譯器生成的一個個目標文件鏈接成可執行文件。最終得到的文件是分成各種段的，比如數據段、代碼段、BSS段等等，運行時會被裝載到內存中。各個段具有不同的讀寫、執行屬性，保護了程序的安全運行。

這部分內容，推薦看《程序員的自我修養》和《深入理解計算機系統》。

Go 程序啟動

仍然使用 hello-world 項目的例子。在項目根目錄下執行：

<code>go build -gcflags "-N -l" -o hello src/main.go
/<code>

-gcflags"-N -l" 是為了關閉編譯器優化和函數內聯，防止後面在設置斷點的時候找不到相對應的代碼位置。

得到了可執行文件 hello，執行：

<code>[qcrao@qcrao hello-world]$ gdb hello/<code>

進入 gdb 調試模式，執行 info files，得到可執行文件的文件頭，列出了各種段：

同時，我們也得到了入口地址：0x450e20。

<code>(gdb) b *0x450e20  

Breakpoint 1 at 0x450e20: file /usr/local/go/src/runtime/rt0_linux_amd64.s, line 8./<code>

這就是 Go 程序的入口地址，我是在 linux 上運行的，所以入口文件為 src/runtime/rt0_linux_amd64.s，runtime 目錄下有各種不同名稱的程序入口文件，支持各種操作系統和架構，代碼為：

<code>TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8 
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX/<code>

主要是把 argc，argv 從內存拉到了寄存器。這裡 LEAQ 是計算內存地址，然後把內存地址本身放進寄存器裡，也就是把 argv 的地址放到了 SI 寄存器中。最後跳轉到：

<code>TEXT main(SB),NOSPLIT,$-8 
MOVQ $runtime·rt0_go(SB), AX
JMP AX/<code>

繼續跳轉到 runtime·rt0_go(SB)，位置：/usr/local/go/src/runtime/asm_amd64.s，代碼：

<code>TEXT runtime·rt0_go(SB),NOSPLIT,$0 
// 省略很多 CPU 相關的特性標誌位檢查的代碼
// 主要是看不懂，^_^
// ………………………………
// 下面是最後調用的一些函數，比較重要
// 初始化執行文件的絕對路徑 

CALL runtime·args(SB)
// 初始化 CPU 個數和內存頁大小
CALL runtime·osinit(SB)
// 初始化命令行參數、環境變量、gc、棧空間、內存管理、所有 P 實例、HASH算法等
CALL runtime·schedinit(SB)
// 要在 main goroutine 上運行的函數
MOVQ $runtime·mainPC(SB), AX // entry
PUSHQ AX
PUSHQ $0 // arg size
// 新建一個 goroutine，該 goroutine 綁定 runtime.main，放在 P 的本地隊列，等待調度
CALL runtime·newproc(SB)
POPQ AX
POPQ AX
// 啟動M，開始調度goroutine
CALL runtime·mstart(SB)
MOVL $0xf1, 0xf1 // crash
RET
DATA runtime·mainPC+0(SB)/8,$runtime·main(SB)
GLOBL runtime·mainPC(SB),RODATA,$8/<code>

參考文獻裡的一篇文章【探索 golang 程序啟動過程】研究得比較深入，總結下：

1. 檢查運行平臺的CPU，設置好程序運行需要相關標誌。

2. TLS的初始化。

3. runtime.args、runtime.osinit、runtime.schedinit 三個方法做好程序運行需要的各種變量與調度器。

4. runtime.newproc創建新的goroutine用於綁定用戶寫的main方法。

5. runtime.mstart開始goroutine的調度。

最後用一張圖來總結 go bootstrap 過程吧：

main 函數里執行的一些重要的操作包括：新建一個線程執行 sysmon 函數，定期垃圾回收和調度搶佔；啟動 gc；執行所有的 init 函數等等。

上面是啟動過程，看一下退出過程：

當 main 函數執行結束之後，會執行 exit(0) 來退出進程。若執行 exit(0) 後，進程沒有退出，main 函數最後的代碼會一直訪問非法地址：

<code>exit(0) 
for {
var x *int32
*x = 0
}/<code>

正常情況下，一旦出現非法地址訪問，系統會把進程殺死，用這樣的方法確保進程退出。

關於程序退出這一段的闡述來自群聊《golang runtime 閱讀》，又是一個高階的讀源碼的組織，Github 主頁見參考資料。

當然 Go 程序啟動這一部分其實還會涉及到 fork 一個新進程、裝載可執行文件，控制權轉移等問題。還是推薦看前面的兩本書，我覺得我不會寫得更好，就不敘述了。

GoRoot 和 GoPath

GoRoot 是 Go 的安裝路徑。mac 或 unix 是在 /usr/local/go 路徑上，來看下這裡都裝了些什麼：

bin 目錄下面：

pkg 目錄下面：

Go 工具目錄如下，其中比較重要的有編譯器 compile，鏈接器 link：

GoPath 的作用在於提供一個可以尋找 .go 源碼的路徑，它是一個工作空間的概念，可以設置多個目錄。Go 官方要求，GoPath 下面需要包含三個文件夾：

<code>src 
pkg
bin/<code>

src 存放源文件，pkg 存放源文件編譯後的庫文件，後綴為 .a；bin 則存放可執行文件。

Go 命令詳解

直接在終端執行：

<code>go
/<code>

就能得到和 go 相關的命令簡介：

和編譯相關的命令主要是：

<code>go build 
go install
go run/<code>

go build

go build 用來編譯指定 packages 裡的源碼文件以及它們的依賴包，編譯的時候會到 $GoPath/src/package 路徑下尋找源碼文件。go build 還可以直接編譯指定的源碼文件，並且可以同時指定多個。

通過執行 go help build 命令得到 go build 的使用方法：

<code>usage: go build [-o output] [-i] [build flags] [packages]/<code>

-o 只能在編譯單個包的時候出現，它指定輸出的可執行文件的名字。

-i 會安裝編譯目標所依賴的包，安裝是指生成與代碼包相對應的 .a 文件，即靜態庫文件（後面要參與鏈接），並且放置到當前工作區的 pkg 目錄下，且庫文件的目錄層級和源碼層級一致。

至於 build flags 參數， build,clean,get,install,list,run,test 這些命令會共用一套：

我們知道，Go 語言的源碼文件分為三類：命令源碼、庫源碼、測試源碼。

• 命令源碼文件：是 Go 程序的入口，包含 func main 函數，且第一行用 packagemain 聲明屬於 main 包。

• 庫源碼文件：主要是各種函數、接口等，例如工具類的函數。

• 測試源碼文件：以 _test.go 為後綴的文件，用於測試程序的功能和性能。

注意， go build 會忽略 *_test.go 文件。

我們通過一個很簡單的例子來演示 go build 命令。我用 Goland 新建了一個 hello-world 項目（為了展示引用自定義的包，和之前的 hello-world 程序不同），項目的結構如下：

最左邊可以看到項目的結構，包含三個文件夾：bin，pkg，src。其中 src 目錄下有一個 main.go，裡面定義了 main 函數，是整個項目的入口，也就是前面提過的所謂的命令源碼文件；src 目錄下還有一個 util 目錄，裡面有 util.go 文件，定義了一個可以獲取本機 IP 地址的函數，也就是所謂的庫源碼文件。

中間是 main.go 的源碼，引用了兩個包，一個是標準庫的 fmt；一個是 util 包，util 的導入路徑是 util。所謂的導入路徑是指相對於 Go 的源碼目錄 $GoRoot/src 或者 $GoPath/src 的下的子路徑。例如 main 包裡引用的 fmt 的源碼路徑是 /usr/local/go/src/fmt，而 util 的源碼路徑是 /Users/qcrao/hello-world/src/util，正好我們設置的 GoPath = /Users/qcrao/hello-world。

最右邊是庫函數的源碼，實現了獲取本機 IP 的函數。

在 src 目錄下，直接執行 go build 命令，在同級目錄生成了一個可執行文件，文件名為 src，使用 ./src 命令直接執行，輸出：

<code>hello world! 
Local IP: 192.168.1.3/<code>

我們也可以指定生成的可執行文件的名稱：

<code>go build -o bin/hello/<code>

這樣，在 bin 目錄下會生成一個可執行文件，運行結果和上面的 src 一樣。

其實，util 包可以單獨被編譯。我們可以在項目根目錄下執行：

<code>go build util/<code>

編譯程序會去 $GoPath/src 路徑找 util 包（其實是找文件夾）。還可以在 ./src/util 目錄下直接執行 go build 編譯。

當然，直接編譯庫源碼文件不會生成 .a 文件，因為：

go build 命令在編譯只包含庫源碼文件的代碼包（或者同時編譯多個代碼包）時，只會做檢查性的編譯，而不會輸出任何結果文件。

為了展示整個編譯鏈接的運行過程，我們在項目根目錄執行如下的命令：

<code>go build -v -x -work -o bin/hello src/main.go/<code>

-v 會打印所編譯過的包名字， -x 打印編譯期間所執行的命令， -work 打印編譯期間生成的臨時文件路徑，並且編譯完成之後不會被刪除。

執行結果：

從結果來看，圖中用箭頭標註了本次編譯過程涉及 2 個包：util，command-line-arguments。第二個包比較詭異，源碼里根本就沒有這個名字好嗎？其實這是 go build 命令檢測到 [packages] 處填的是一個 .go 文件，因此創建了一個虛擬的包：command-line-arguments。

同時，用紅框圈出了 compile, link，也就是先編譯了 util 包和 main.go 文件，分別得到 .a 文件，之後將兩者進行鏈接，最終生成可執行文件，並且移動到 bin 目錄下，改名為 hello。

另外，第一行顯示了編譯過程中的工作目錄，此目錄的文件結構是：

可以看到，和 hello-world 目錄的層級基本一致。command-line-arguments 就是虛擬的 main.go 文件所處的包。exe 目錄下的可執行文件在最後一步被移動到了 bin 目錄下，所以這裡是空的。

整體來看， go build 在執行時，會先遞歸尋找 main.go 所依賴的包，以及依賴的依賴，直至最底層的包。這裡可以是深度優先遍歷也可以是寬度優先遍歷。如果發現有循環依賴，就會直接退出，這也是經常會發生的循環引用編譯錯誤。

正常情況下，這些依賴關係會形成一棵倒著生長的樹，樹根在最上面，就是 main.go 文件，最下面是沒有任何其他依賴的包。編譯器會從最左的節點所代表的包開始挨個編譯，完成之後，再去編譯上一層的包。

這裡，引用郝林老師幾年前在 github 上發表的 go 命令教程，可以從參考資料找到原文地址。

從代碼包編譯的角度來說，如果代碼包 A 依賴代碼包 B，則稱代碼包 B 是代碼包 A 的依賴代碼包（以下簡稱依賴包），代碼包 A 是代碼包 B 的觸發代碼包（以下簡稱觸發包）。

執行 go build 命令的計算機如果擁有多個邏輯 CPU 核心，那麼編譯代碼包的順序可能會存在一些不確定性。但是，它一定會滿足這樣的約束條件：依賴代碼包 -> 當前代碼包 -> 觸發代碼包。

順便推薦一個瀏覽器插件 Octotree，在看 github 項目的時候，此插件可以在瀏覽器裡直接展示整個項目的文件結構，非常方便：

到這裡，你一定會發現，對於 hello-wrold 文件夾下的 pkg 目錄好像一直沒有涉及到。

其實，pkg 目錄下面應該存放的是涉及到的庫文件編譯後的包，也就是一些 .a 文件。但是 go build 執行過程中，這些 .a 文件放在臨時文件夾中，編譯完成後會被直接刪掉，因此一般不會用到。

前面我們提到過，在 go build 命令里加上 -i 參數會安裝這些庫文件編譯的包，也就是這些 .a 文件會放到 pkg 目錄下。

在項目根目錄執行 go build-i src/main.go 後，pkg 目錄裡增加了 util.a 文件：

darwin_amd64 表示的是：

• GOOS 和 GOARCH。這兩個環境變量不用我們設置，系統默認的。

• GOOS 是 Go 所在的操作系統類型，GOARCH 是 Go 所在的計算架構。

• Mac 平臺上這個目錄名就是 darwin_amd64。

生成了 util.a 文件後，再次編譯的時候，就不會再重新編譯 util.go 文件，加快了編譯速度。

同時，在根目錄下生成了名稱為 main 的可執行文件，這是以 main.go 的文件名命令的。

hello-world 這個項目的代碼已經上傳到了 github 項目 Go-Questions，這個項目由問題導入，企圖串連 Go 的所有知識點，正在完善，期待你的 star。地址見參考資料【Go-Questions hello-world項目】。

go install

go install 用於編譯並安裝指定的代碼包及它們的依賴包。相比 go build，它只是多了一個“安裝編譯後的結果文件到指定目錄”的步驟。

還是使用之前 hello-world 項目的例子，我們先將 pkg 目錄刪掉，在項目根目錄執行：

<code>go install src/main.go 
或者
go install util
/<code>

兩者都會在根目錄下新建一個 pkg 目錄，並且生成一個 util.a 文件。

並且，在執行前者的時候，會在 GOBIN 目錄下生成名為 main 的可執行文件。

所以，運行 go install 命令，庫源碼包對應的 .a 文件會被放置到 pkg 目錄下，命令源碼包生成的可執行文件會被放到 GOBIN 目錄。

go install 在 GoPath 有多個目錄的時候，會產生一些問題，具體可以去看郝林老師的 Go命令教程，這裡不展開了。

go run

go run 用於編譯並運行命令源碼文件。

在 hello-world 項目的根目錄，執行 go run 命令：

<code>go run -x -work src/main.go/<code>

-x 可以打印整個過程涉及到的命令，-work 可以看到臨時的工作目錄：

從上圖中可以看到，仍然是先編譯，再連接，最後直接執行，並打印出了執行結果。

第一行打印的就是工作目錄，最終生成的可執行文件就是放置於此：

main 就是最終生成的可執行文件。

總結

這次的話題太大了，困難重重。從編譯原理到 go 啟動時的流程，到 go 命令原理，每個話題單獨抽出來都可以寫很多。

幸好有一些很不錯的書和博客文章可以去參考。這篇文章就作為一個引子，你可以跟隨參考資料裡推薦的一些內容去發散。

• 【《程序員的自我修養》全書】https://book.douban.com/subject/3652388/

• 【面向信仰編程 編譯過程概述】https://draveness.me/golang-compile-intro

• 【golang runtime 閱讀】https://github.com/zboya/golangruntimereading

• 【Go-Questions hello-world項目】https://github.com/qcrao/Go-Questions/tree/master/examples/hello-world

• 【雨痕大佬的 Go 語言學習筆記】https://github.com

  /qyuhen/book

• 【vim 以 16 進制文本】https://www.cnblogs.com/meibenjin/archive/2012/12/06/2806396.html

• 【Go 編譯命令執行過程】https://halfrost.com/go_command/

• 【Go 命令執行過程】https://github.com/hyper0x/gocommandtutorial

• 【Go 詞法分析】https://ggaaooppeenngg.github.io/zh-CN/2016/04/01/go-lexer-%E8%AF%8D%E6%B3%95%E5%88%86%E6%9E%90/

• 【曹大博客 golang 與 ast】http://xargin.com/ast/

• 【Golang 詞法解析器，scanner 源碼分析】https://blog.csdn.net/zhaoruixiang1111/article/details/89892435

• 【Gopath Explained】https://flaviocopes.com/go-gopath/

• 【Understanding the GOPATH】https://

  www.digitalocean.com/community/tutorials/understanding-the-gopath

• 【討論】https://stackoverflow.com/questions/7970390/what-should-be-the-values-of-gopath-and-goroot

• 【Go 官方 Gopath】https://golang.org/cmd/go/#hdr-GOPATHenvironmentvariable

• 【Go package 的探索】https://mp.weixin.qq.com/s/OizVLXfZ6EC1jI-NL7HqeA

• 【Go 官方 關於 Go 項目的組織結構】https://golang.org/doc/code.html

• 【Go modules】https://www.melvinvivas.com/go-version-1-11-modules/

• 【Golang Installation, Setup, GOPATH, and Go Workspace】https://www.callicoder.com/golang-installation-setup-gopath-workspace/

• 【編譯、鏈接過程鏈接】https://mikespook

  .com/2013/11/%E7%BF%BB%E8%AF%91-go-build-%E5%91%BD%E4%BB%A4%E6%98%AF%E5%A6%82%E4%BD%95%E5%B7%A5%E4%BD%9C%E7%9A%84%EF%BC%9F/

• 【1.5 編譯器由 go 語言完成】https://www.infoq.cn/article/2015/08/go-1-5

• 【Go 編譯過程系列文章】https://www.ctolib.com/topics-3724.html

• 【曹大 go bootstrap】https://github.com/cch123/golang-notes/blob/master/bootstrap.md

• 【golang 啟動流程】https://blog.iceinto.com/posts/go/start/

• 【探索 golang 程序啟動過程】http://cbsheng.github.io/posts/%E6%8E%A2%E7%B4%A2golang%E7%A8%8B%E5%BA%8F%E5%90%AF%E5%8A%A8%E8%BF%87%E7%A8%8B/

• 【探索 goroutine 的創建】http://cbsheng.github.io/posts/%E6%8E%A2%E7%B4%A2goroutine%E7%9A%84%E5%88%9B%E5%BB%BA/

【END】

1024程序員節如期而至，CSDN Blink小姐姐的關愛來了！

掃描領取小姐姐的專屬福利！

程序員邂逅鼓勵師的正確姿勢！掃描前往福利現場>>

閱讀更多 CSDN 的文章

關鍵字: GNU CSDN Vim