bmf mysql_bmf 的动态 - SegmentFault 思否
函數的調用過程主要要點在于借助寄存器和內存幀棧傳遞參數和返回值。雖然同為編譯型語言，Go 相較 C 對寄存器和棧的使用有一些差別，同時，Go 語言自帶協程并引入 defer 等語句，在調用過程上顯得更加復雜。 理解Go函數調用在CPU指令層的過程有助于編寫高效的代碼，在性能優化、Bug排查的時候，能更迅速的確定要點。本文以簡短的示例代碼和對應的匯編代碼演示了Go的調用過程，展示了不同數據類型的參數的實際傳遞過程，同時分析了匿名函數、閉包作為參數或者返回值傳遞時，在內存上的實際數據結構。對于協程對棧的使用和實現細節，本文不展開。
閱讀本文需要掌握計算機體系結構基礎知識(至少了解程序內存布局、棧、寄存器)、Go 基礎語法。參考文檔提供了這些主題更詳細的知識。
以下：
術語棧：每個進程/線程/goroutine有自己的調用棧，參數和返回值傳遞、函數的局部變量存放通常通過棧進行。和數據結構中的棧一樣，內存棧也是后進先出，地址是從高地址向低地址生長。
棧幀：(stack frame)又常被稱為幀(frame)。一個棧是由很多幀構成的，它描述了函數之間的調用關系。每一幀就對應了一次尚未返回的函數調用，幀本身也是以棧的形式存放數據的。
caller 調用者
callee 被調用者，如在 函數 A 里 調用 函數 B，A 是 caller，B 是 callee
寄存器(X86)ESP：棧指針寄存器(extended stack pointer)，存放著一個指針，該指針指向棧最上面一個棧幀(即當前執行的函數的棧)的棧頂。注意：ESP指向的是已經存儲了內容的內存地址，而不是一個空閑的地址。例如從 0xC0000000 到 0xC00000FF是已經使用的棧空間，ESP指向0xC00000FF
EBP：基址指針寄存器(extended base pointer)，也叫幀指針，存放著一個指針，該指針指向棧最上面一個棧幀的底部。
EIP：寄存器存放下一個CPU指令存放的內存地址，當CPU執行完當前的指令后，從EIP寄存器中讀取下一條指令的內存地址，然后繼續執行。
注意：16位寄存器沒有前綴(SP、BP、IP)，32位前綴是E(ESP、EBP、EIP)，64位前綴是R(RSP、RBP、RIP)
匯編指令PUSH：進棧指令，PUSH指令執行時會先將ESP減4，接著將內容寫入ESP指向的棧內存。
POP ：出棧指令，POP指令執行時先將ESP指向的棧內存的一個字長的內容讀出，接著將ESP加4。注意：用PUSH指令和POP指令時只能按字訪問棧，不能按字節訪問棧。
CALL：調用函數指令，將返回地址(call指令的下一條指令)壓棧，接著跳轉到函數入口。
RET：返回指令，將棧頂返回地址彈出到EIP，接著根據EIP繼續執行。
LEAVE：等價于 mov esp,ebp; pop ebp;
MOVL：在內存與寄存器、寄存器與寄存器之間轉移值
LEAL：用來將一個內存地址直接賦給目的操作數
注意：8位指令后綴是B、16位是S、32位是L、64位是Q
調用慣例
調用慣例(calling convention)是指程序里調用函數時關于如何傳參如何分配和清理棧等的方案。一個調用慣例的內容包括：參數是通過寄存器傳遞還是棧傳遞或者二者混合
通過棧傳遞時參數是從左至右壓棧還是從右至左壓棧
函數結果是通過寄存器傳遞還是通過棧傳遞
調用者(caller)還是被調用者(callee)清理棧空間
被調用者應該為調用者保存哪些寄存器
例如，C 的調用慣例(cdecl, C declaration)是：
函數實參在線程棧上按照從右至左的順序依次壓棧。
函數結果保存在寄存器EAX/AX/AL中
浮點型結果存放在寄存器ST0中
編譯后的函數名前綴以一個下劃線字符
調用者負責從線程棧中彈出實參(即清棧)
8比特或者16比特長的整形實參提升為32比特長。
受到函數調用影響的寄存器(volatile registers)：EAX, ECX, EDX, ST0 - ST7, ES, GS
不受函數調用影響的寄存器： EBX, EBP, ESP, EDI, ESI, CS, DS
RET指令從函數被調用者返回到調用者(實質上是讀取寄存器EBP所指的線程棧之處保存的函數返回地址并加載到IP寄存器)
cdecl 將函數返回值保存在寄存器中，所以 C 語言不支持多個返回值。另外，cdecl 是調用者負責清棧，因而可以實現可變參數的函數。如果是被調用者負責清理的話，無法實現可變參數的函數，但是編譯代碼的效率會高一點，因為清理棧的代碼不用在每次調用的時候(編譯器計算)生成一遍。(x86的ret指令允許一個可選的16位參數說明棧字節數，用來在返回給調用者之前解堆棧。代碼類似ret 12這樣，如果遇到這樣的匯編代碼，說明是被調用者清棧。)
注意，雖然 C 語言 里都是借助寄存器傳遞返回值，但是返回值大小不同時有不同的處理情形。若小于4字節，返回值存入eax寄存器，由函數調用方讀取eax。若返回值5到8字節，采用eax和edx聯合返回。若大于8個字節，首先在棧上額外開辟一部分空間temp，將temp對象的地址做為隱藏參數入棧。函數返回時將數據拷貝給temp對象，并將temp對象的地址用寄存器eax傳出。調用方從eax指向的temp對象拷貝內容。
可以看到，設計一個編程語言的特性時，需要為其選擇合適調用慣例才能在底層實現這些特性。(調用慣例是編程語言的編譯器選擇的，同樣的語言不同的編譯器可能會選擇實現不同的調用慣例)
一次典型的 C 函數調用過程
在caller里：將實參從右至左壓棧(X86-64下是：將實參寫入寄存器，如果實參超過 6 個，超出的從右至左壓棧)
執行 call 指令(會將返回地址壓棧，并跳轉到 callee 入口)
進入callee里：push ebp; mov ebp,esp; 此時EBP和ESP已經分別表示callee的棧底和棧頂了。之后 EBP 的值會保持固定。此后局部變量和臨時存儲都可以通過基準指針EBP加偏移量找到了。
sub xxx, esp; 棧頂下移，為callee分配空間，用于存放局部變量等。分配的內存單元可以通過 EBP - K 或者 ESP + K 得到地址訪問。
將某些寄存器的值壓棧(可能)
callee執行
將某些寄存器值彈出棧(可能)
mov esp,ebp; pop ebp; (這兩條指令也可以用 leave 指令替代)此時 EBP 和 ESP 回到了進入callee之前的狀態，即分別表示caller的棧底和棧頂狀態。
執行 ret 指令
回到了caller里的代碼
int add(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8) {
return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8;
}
int main() {
int i = add(1, 2, 3 , 4, 5, 6, 7, 8);
}
x86版匯編.section __TEXT,__text,regular,pure_instructions
.build_version macos, 10, 14 sdk_version 10, 14
.globl _add ## -- Begin function add
.p2align 4, 0x90
_add: ## @add
.cfi_startproc
## %bb.0:
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset %ebp, -8
movl %esp, %ebp
.cfi_def_cfa_register %ebp
pushl %ebx
pushl %edi
pushl %esi
subl $32, %esp
.cfi_offset %esi, -20
.cfi_offset %edi, -16
.cfi_offset %ebx, -12
movl 36(%ebp), %eax
movl 32(%ebp), %ecx
movl 28(%ebp), %edx
movl 24(%ebp), %esi
movl 20(%ebp), %edi
movl 16(%ebp), %ebx
movl %eax, -16(%ebp) ## 4-byte Spill
movl 12(%ebp), %eax
movl %eax, -20(%ebp) ## 4-byte Spill
movl 8(%ebp), %eax
movl %eax, -24(%ebp) ## 4-byte Spill
movl 8(%ebp), %eax
addl 12(%ebp), %eax
addl 16(%ebp), %eax
addl 20(%ebp), %eax
addl 24(%ebp), %eax
addl 28(%ebp), %eax
addl 32(%ebp), %eax
addl 36(%ebp), %eax
movl %ebx, -28(%ebp) ## 4-byte Spill
movl %ecx, -32(%ebp) ## 4-byte Spill
movl %edx, -36(%ebp) ## 4-byte Spill
movl %esi, -40(%ebp) ## 4-byte Spill
movl %edi, -44(%ebp) ## 4-byte Spill
addl $32, %esp
popl %esi
popl %edi
popl %ebx
popl %ebp
retl
.cfi_endproc
## -- End function
.globl _main ## -- Begin function main
.p2align 4, 0x90
_main: ## @main
.cfi_startproc
## %bb.0:
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset %ebp, -8
movl %esp, %ebp
.cfi_def_cfa_register %ebp
subl $40, %esp
movl $1, (%esp)
movl $2, 4(%esp)
movl $3, 8(%esp)
movl $4, 12(%esp)
movl $5, 16(%esp)
movl $6, 20(%esp)
movl $7, 24(%esp)
movl $8, 28(%esp)
calll _add
xorl %ecx, %ecx
movl %eax, -4(%ebp)
movl %ecx, %eax
addl $40, %esp
popl %ebp
retl
.cfi_endproc
## -- End function
.subsections_via_symbols
x86-64版匯編.section __TEXT,__text,regular,pure_instructions
.build_version macos, 10, 14 sdk_version 10, 14
.globl _add ## -- Begin function add
.p2align 4, 0x90
_add: ## @add
.cfi_startproc
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
movl 24(%rbp), %eax
movl 16(%rbp), %r10d
movl %edi, -4(%rbp)
movl %esi, -8(%rbp)
movl %edx, -12(%rbp)
movl %ecx, -16(%rbp)
movl %r8d, -20(%rbp)
movl %r9d, -24(%rbp)
movl -4(%rbp), %ecx
addl -8(%rbp), %ecx
addl -12(%rbp), %ecx
addl -16(%rbp), %ecx
addl -20(%rbp), %ecx
addl -24(%rbp), %ecx
addl 16(%rbp), %ecx
addl 24(%rbp), %ecx
movl %eax, -28(%rbp) ## 4-byte Spill
movl %ecx, %eax
movl %r10d, -32(%rbp) ## 4-byte Spill
popq %rbp
retq
.cfi_endproc
## -- End function
.globl _main ## -- Begin function main
.p2align 4, 0x90
_main: ## @main
.cfi_startproc
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
subq $32, %rsp
movl $1, %edi
movl $2, %esi
movl $3, %edx
movl $4, %ecx
movl $5, %r8d
movl $6, %r9d
movl $7, (%rsp)
movl $8, 8(%rsp)
callq _add
xorl %ecx, %ecx
movl %eax, -4(%rbp)
movl %ecx, %eax
addq $32, %rsp
popq %rbp
retq
.cfi_endproc
## -- End function
.subsections_via_symbols
可以看到 Clang 編譯出的X86目標代碼并不使用寄存器傳遞參數，而X86-64目標代碼里，使用寄存器傳遞前六個參數。
一次典型的Go函數調用過程
Go 選擇的調用慣例是：參數完全通過棧傳遞，從參數列表的右至左壓棧
返回值通過棧傳遞，返回值的棧空間在參數之前，即返回值在更接近caller棧底的位置
caller負責清理棧package main
func main() {
add(1,2)
}
//go:noinline
func add(a , b int) int {
c := 3
d := a + b + c
return d
}TEXT main.main(SB) /Users/user/go/src/test/main.go
main.go:4 0x104ea20 65488b0c2530000000 MOVQ GS:0x30, CX
main.go:4 0x104ea29 483b6110 CMPQ 0x10(CX), SP
main.go:4 0x104ea2d 762e JBE 0x104ea5d
main.go:4 0x104ea2f 4883ec20 SUBQ $0x20, SP ; 增加 32 bytes 的棧空間(四個 qword，8個bytes 為一個 qword)
main.go:4 0x104ea33 48896c2418 MOVQ BP, 0x18(SP) ; 將 BP 的值寫入到剛分配的棧空間的第一個qword
main.go:4 0x104ea38 488d6c2418 LEAQ 0x18(SP), BP ; 將剛分配的棧空間的第一個字的地址賦值給BP(即BP此時指向了剛才存放舊BP值的地址)
main.go:5 0x104ea3d 48c7042401000000 MOVQ $0x1, 0(SP); 將給add函數的第一個實參值1 寫入到剛分配棧空間的最后一個qword
main.go:5 0x104ea45 48c744240802000000 MOVQ $0x2, 0x8(SP); 將給add函數的第二個實參值2 寫入到剛分配棧空間的第三個qword。第二個 qword 沒有用到，實際上是給callee用來存放返回值的。
main.go:5 0x104ea4e e81d000000 CALL main.add(SB); 調用 add 函數
main.go:6 0x104ea53 488b6c2418 MOVQ 0x18(SP), BP; 將從棧里第四個qword將舊的BP值取回賦值到BP
main.go:6 0x104ea58 4883c420 ADDQ $0x20, SP; 增加SP的值，棧收縮，收回 32 bytes的棧空間
main.go:6 0x104ea5c c3 RET
TEXT main.add(SB) /Users/user/go/src/test/main.go
main.go:11 0x104ea70 4883ec18 SUBQ $0x18, SP; 分配 24 bytes 的棧空間(3 個 qword)。
main.go:11 0x104ea74 48896c2410 MOVQ BP, 0x10(SP); 將 BP值 寫入第一個qword
main.go:11 0x104ea79 488d6c2410 LEAQ 0x10(SP), BP; 將剛分配的24 bytes 棧空間的第一個字的地址賦值給BP(即BP此時指向了剛才存放舊BP值的地址)
main.go:11 0x104ea7e 48c744243000000000 MOVQ $0x0, 0x30(SP);將存放返回值的地址清零，0x30(SP) 對應的內存位置是上一段 main.main 里分配的棧空間的第二個qword。
main.go:12 0x104ea87 48c744240803000000 MOVQ $0x3, 0x8(SP); 對應 c := 3 這行代碼。局部變量 c 對應的是棧上內存。3 被寫入到剛分配的 24 bytes 空間的第二個qword。
main.go:13 0x104ea90 488b442420 MOVQ 0x20(SP), AX; 將add的實參 1 寫入到AX 寄存器。
main.go:13 0x104ea95 4803442428 ADDQ 0x28(SP), AX; 將add的實參 2 增加到 AX 寄存器。
main.go:13 0x104ea9a 4883c003 ADDQ $0x3, AX; 將局部變量值 3 增加到 AX 寄存器
main.go:13 0x104ea9e 48890424 MOVQ AX, 0(SP); 將 AX 的值(計算結果) 寫入到剛分配的 24 bytes 空間的第三個qword。(對應代碼 d := a + b + c)
main.go:14 0x104eaa2 4889442430 MOVQ AX, 0x30(SP); 將 AX 的值寫入到main里為返回值留的棧空間(main里分配的32 bytes 中的第二個 qword)
main.go:14 0x104eaa7 488b6c2410 MOVQ 0x10(SP), BP; 恢復BP的值為函數入口處保存的舊BP的值。
main.go:14 0x104eaac 4883c418 ADDQ $0x18, SP; 將 SP 增加三個字，收回add入口處分配的棧空間。
main.go:14 0x104eab0 c3 RET
函數調用過程中，棧的變化情況如圖：
初始狀態：
call add執行前棧狀態：
進入add里之后棧狀態：
add里ret執行前棧狀態：
main里ret執行前棧狀態：
可以看到 Go 的調用過程和 C 類似，區別在于 Go 的參數完全通過棧傳遞，Go 的返回值也是通過棧傳遞。對于每種數據類型在作為參數傳遞時的表現，可以測試一下：
不同數據類型作為參數時的傳遞方式
Go 基礎數據類型的參數傳遞package main
import (
"fmt"
"runtime/debug"
)
func main() {
str := "hello"
int8 := int8(8)
int64 := int64(64)
boolValue := true
ExampleStr(str)
ExampleBool(boolValue)
ExampleInt8(int8)
ExampleInt64(int64)
ExampleMultiParams(false, 9, 8, 7)
}
func ExampleStr(str string){
fmt.Println(string(debug.Stack()))
}
func ExampleBool(boolValue bool){
boolValue = false
fmt.Println(string(debug.Stack()))
}
func ExampleInt64(v int64){
fmt.Println(string(debug.Stack()))
}
func ExampleInt8(v int8){
fmt.Println(string(debug.Stack()))
}
func ExampleMultiParams(b bool, x, y, z int8){
bl := b
xl := x
yl := y
zl := z
fmt.Println(bl, xl, yl, zl)
fmt.Println(string(debug.Stack()))
}goroutine 1 [running]:
runtime/debug.Stack(0xc000084f38, 0x1057aad, 0x10aeb20)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleStr(0x10c6c34, 0x5)
/Users/user/go/src/test/main.go:25 +0x26
main.main()
/Users/user/go/src/test/main.go:16 +0x36
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleBool(0x10c6c01)
/Users/user/go/src/test/main.go:32 +0x26
main.main()
/Users/user/go/src/test/main.go:17 +0x3f
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleInt8(0x10c6c08)
/Users/user/go/src/test/main.go:42 +0x26
main.main()
/Users/user/go/src/test/main.go:18 +0x48
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleInt64(0x40)
/Users/user/go/src/test/main.go:38 +0x26
main.main()
/Users/user/go/src/test/main.go:19 +0x55
false 9 8 7
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f28)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleMultiParams(0x7080900)
/Users/user/go/src/test/main.go:52 +0xf6
main.main()
/Users/user/go/src/test/main.go:20 +0x61
可以看到：string傳遞時，分為pointer和length兩個參數傳遞。
int64傳遞時，復制了值進行傳遞。
看debug.Stack()打印出的調用棧，int8和bool傳遞時，傳遞的是一個內存地址，這似乎容易引起誤解，難道傳遞的是caller里變量的內存地址？那不是會導致callee修改也導致caller里值也發生改變？當然不是這樣！int和bool當然都是值傳遞。當caller傳遞給callee的時候，int和bool都會被在caller的棧里復制一份給callee使用。(在callee直接通過引用參數名修改參數值，這個參數的內存位置實際上是在caller的棧上)。
ExampleMultiParams函數雖然有四個參數，但是調用棧打印出來只傳遞了一個值 0x7080900，這是為什么？原來這四個參數都是一個byte，合起來是一個雙字。查看匯編代碼可以發現編譯器做了優化，直接組合成一個值，并在caller里用指令MOVL $0x7080900, 0(SP)寫入棧上。當然，在caller里取值的時候，還是借助MOVB去一個字節一個字節取值的。當然，如果是這四個參數是main里的四個局部變量，調用ExampleMultiParams的時候通過傳遞變量名的形式調用(ExampleMultiParams(b, x, y, z)而不是 ExampleMultiParams(true, 9, 8, 7)的形式)，體現在匯編代碼里又是另一種形式。
Go 組合數據類型的參數傳遞package main
import (
"fmt"
"runtime/debug"
)
type MyStruct struct {
a int
b string
}
func main() {
slice := make([]string, 2, 4)
array := [...]int{9,8,7,6,7,8,9}
myMap := make(map[string]int)
myStruct := MyStruct{8, "test"}
myStructPtr := &myStruct
myChan := make(chan int, 4)
ExampleSlice(slice)
ExampleArray(array)
ExampleMap(myMap)
ExampleStruct(myStruct)
ExamplePtr(myStructPtr)
ExampleChan(myChan)
}
func ExampleSlice(slice []string){
fmt.Println(string(debug.Stack()))
}
func ExampleArray(array [7]int){
fmt.Println(string(debug.Stack()))
}
func ExampleMap(myMap map[string]int){
fmt.Println(string(debug.Stack()))
}
func ExampleStruct(myStruct MyStruct){
fmt.Println(string(debug.Stack()))
}
func ExamplePtr(ptr *MyStruct){
fmt.Println(string(debug.Stack()))
}
func ExampleChan(myChan chan int){
fmt.Println(string(debug.Stack()))
}
調用棧goroutine 1 [running]:
runtime/debug.Stack(0x130a568, 0xc00007eda8, 0x1004218)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleSlice(0xc00007ee78, 0x2, 0x4)
/Users/user/go/src/test/main.go:62 +0x26
main.main()
/Users/user/go/src/test/main.go:46 +0x159
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleArray(0x9, 0x8, 0x7, 0x6, 0x7, 0x8, 0x9)
/Users/user/go/src/test/main.go:66 +0x26
main.main()
/Users/user/go/src/test/main.go:48 +0x185
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleMap(0xc00007ee48)
/Users/user/go/src/test/main.go:74 +0x26
main.main()
/Users/user/go/src/test/main.go:52 +0x1af
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleStruct(0x8, 0x10c6f88, 0x4)
/Users/user/go/src/test/main.go:78 +0x26
main.main()
/Users/user/go/src/test/main.go:54 +0x1d7
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExamplePtr(0xc00007ee30)
/Users/user/go/src/test/main.go:82 +0x26
main.main()
/Users/user/go/src/test/main.go:56 +0x1e5
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleChan(0xc000092000)
/Users/user/go/src/test/main.go:86 +0x26
main.main()
/Users/user/go/src/test/main.go:58 +0x1f3
可以看到：對于數組、結構體、指針，是復制一份拷貝傳遞給callee。
數組作為參數時，編譯后參數的數量是數組元素的數量。
結構體作為參數時，編譯后參數的數量需要再次分析結構體里元素的類型。如上述代碼里結構體由一個int和一個string組成，傳遞參數時是int值、string的地址、string的長度三個參數。
slice傳遞時，會將slice底層的pointer、len、cap作為三個參數分開傳遞。(即編譯后，參數數量由源代碼里的一個參數變為了三個參數)。所以slice其實也是值傳遞。
map、chan傳遞時，是將map、chan的地址指針作為參數傳遞。
方法：pointer receiver 與 value receiver
在 Java 中，當我們調用一個對象的方法的時候，當然是可以修改對象的成員變量的。但是在 Go 中，結果取決于定義方法時方法的接收者是值還是指針(value receiver 和 pointer receiver)。Go 的方法接收者有兩種，一種是值接收者(value receiver)，一種是指針接收者(pointer receiver)。值接收者，是接收者的類型是一個值，是一個副本，方法內部無法對其真正的接收者做更改。指針接收者，接收者的類型是一個指針，是接收者的引用，對這個引用的修改會影響真正的接收者。
看如下代碼：package main
import "fmt"
type XAxis int
type Point struct{
X int
Y int
}
func (x XAxis)VIncr(offset XAxis){
x += offset
fmt.Printf("In VIncr, new x = %d\n", x)
}
func (x *XAxis)PIncr(offset XAxis){
*x += offset
fmt.Printf("In PIncr, new x = %d\n", *x)
}
func (p Point)VScale(factor int){
p.X *= factor
p.Y *= factor
fmt.Printf("In VScale, new p = %v\n", p)
}
func (p *Point)PScale(factor int){
p.X *= factor
p.Y *= factor
fmt.Printf("In PScale, new p = %v\n", p)
}
func main(){
var x XAxis = 10
fmt.Printf("In main, before VIncr, x = %v\n", x)
x.VIncr(5)
fmt.Printf("In main, after VIncr, new x = %v\n", x)
fmt.Println()
fmt.Printf("In main, before PIncr, x = %v\n", x)
x.PIncr(5)
fmt.Printf("In main, after PIncr, new x = %v\n", x)
fmt.Println()
p := Point{2, 2}
fmt.Printf("In main, before VScale, p = %v\n", p)
p.VScale(5)
fmt.Printf("In main, after VScale, new p = %v\n", p)
fmt.Println()
fmt.Printf("In main, before PScale, p = %v\n", p)
p.PScale(5)
fmt.Printf("In main, after PScale, new p = %v\n", p)
}
輸出：In main, before VIncr, x = 10
In VIncr, new x = 15
In main, after VIncr, new x = 10
In main, before PIncr, x = 10
In PIncr, new x = 15
In main, after PIncr, new x = 15
In main, before VScale, p = {2 2}
In VScale, new p = {10 10}
In main, after VScale, new p = {2 2}
In main, before PScale, p = {2 2}
In PScale, new p = &{10 10}
In main, after PScale, new p = {10 10}
在定義方法的時候，receiver 是在方法名的前面，而不是在參數列表里，那在方法執行的時候，方法內的指令怎么找到receiver的呢？
我們精簡一下代碼(注釋掉 print 相關語句)，然后把反編譯：TEXT %22%22.XAxis.VIncr(SB) gofile../Users/user/go/src/test/main.go
main.go:14 0xbb0 488b442408 MOVQ 0x8(SP), AX
main.go:14 0xbb5 4803442410 ADDQ 0x10(SP), AX
main.go:14 0xbba 4889442408 MOVQ AX, 0x8(SP)
main.go:16 0xbbf c3 RET
TEXT %22%22.(*XAxis).PIncr(SB) gofile../Users/user/go/src/test/main.go
main.go:19 0xbd4 488b442408 MOVQ 0x8(SP), AX
main.go:19 0xbd9 8400 TESTB AL, 0(AX)
main.go:19 0xbdb 488b4c2408 MOVQ 0x8(SP), CX
main.go:19 0xbe0 8401 TESTB AL, 0(CX)
main.go:19 0xbe2 488b00 MOVQ 0(AX), AX
main.go:19 0xbe5 4803442410 ADDQ 0x10(SP), AX
main.go:19 0xbea 488901 MOVQ AX, 0(CX)
main.go:21 0xbed c3 RET
TEXT %22%22.Point.VScale(SB) gofile../Users/user/go/src/test/main.go
main.go:24 0xc0a 488b442408 MOVQ 0x8(SP), AX
main.go:24 0xc0f 488b4c2418 MOVQ 0x18(SP), CX
main.go:24 0xc14 480fafc1 IMULQ CX, AX
main.go:24 0xc18 4889442408 MOVQ AX, 0x8(SP)
main.go:25 0xc1d 488b442410 MOVQ 0x10(SP), AX
main.go:25 0xc22 488b4c2418 MOVQ 0x18(SP), CX
main.go:25 0xc27 480fafc1 IMULQ CX, AX
main.go:25 0xc2b 4889442410 MOVQ AX, 0x10(SP)
main.go:28 0xc30 c3 RET
TEXT %22%22.(*Point).PScale(SB) gofile../Users/user/go/src/test/main.go
main.go:32 0xc47 488b442408 MOVQ 0x8(SP), AX
main.go:32 0xc4c 8400 TESTB AL, 0(AX)
main.go:32 0xc4e 488b4c2408 MOVQ 0x8(SP), CX
main.go:32 0xc53 8401 TESTB AL, 0(CX)
main.go:32 0xc55 488b00 MOVQ 0(AX), AX
main.go:32 0xc58 488b542410 MOVQ 0x10(SP), DX
main.go:32 0xc5d 480fafc2 IMULQ DX, AX
main.go:32 0xc61 488901 MOVQ AX, 0(CX)
main.go:33 0xc64 488b442408 MOVQ 0x8(SP), AX
main.go:33 0xc69 8400 TESTB AL, 0(AX)
main.go:33 0xc6b 488b4c2408 MOVQ 0x8(SP), CX
main.go:33 0xc70 8401 TESTB AL, 0(CX)
main.go:33 0xc72 488b4008 MOVQ 0x8(AX), AX
main.go:33 0xc76 488b542410 MOVQ 0x10(SP), DX
main.go:33 0xc7b 480fafc2 IMULQ DX, AX
main.go:33 0xc7f 48894108 MOVQ AX, 0x8(CX)
main.go:36 0xc83 c3 RET
TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
main.go:38 0xcaa 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE
main.go:38 0xcb3 483b6110 CMPQ 0x10(CX), SP
main.go:38 0xcb7 0f86b3000000 JBE 0xd70
main.go:38 0xcbd 4883ec50 SUBQ $0x50, SP
main.go:38 0xcc1 48896c2448 MOVQ BP, 0x48(SP)
main.go:38 0xcc6 488d6c2448 LEAQ 0x48(SP), BP
main.go:39 0xccb 48c74424300a000000 MOVQ $0xa, 0x30(SP)
main.go:42 0xcd4 48c704240a000000 MOVQ $0xa, 0(SP)
main.go:42 0xcdc 48c744240805000000 MOVQ $0x5, 0x8(SP)
main.go:42 0xce5 e800000000 CALL 0xcea [1:5]R_CALL:%22%22.XAxis.VIncr
main.go:48 0xcea 488d442430 LEAQ 0x30(SP), AX
main.go:48 0xcef 48890424 MOVQ AX, 0(SP)
main.go:48 0xcf3 48c744240805000000 MOVQ $0x5, 0x8(SP)
main.go:48 0xcfc e800000000 CALL 0xd01 [1:5]R_CALL:%22%22.(*XAxis).PIncr
main.go:53 0xd01 0f57c0 XORPS X0, X0
main.go:53 0xd04 0f11442438 MOVUPS X0, 0x38(SP)
main.go:53 0xd09 48c744243802000000 MOVQ $0x2, 0x38(SP)
main.go:53 0xd12 48c744244002000000 MOVQ $0x2, 0x40(SP)
main.go:56 0xd1b 48c7042402000000 MOVQ $0x2, 0(SP)
main.go:56 0xd23 48c744240802000000 MOVQ $0x2, 0x8(SP)
main.go:56 0xd2c 48c744241005000000 MOVQ $0x5, 0x10(SP)
main.go:56 0xd35 e800000000 CALL 0xd3a [1:5]R_CALL:%22%22.Point.VScale
main.go:62 0xd3a 488d442438 LEAQ 0x38(SP), AX
main.go:62 0xd3f 48890424 MOVQ AX, 0(SP)
main.go:62 0xd43 48c744240805000000 MOVQ $0x5, 0x8(SP)
main.go:62 0xd4c e800000000 CALL 0xd51 [1:5]R_CALL:%22%22.(*Point).PScale
main.go:64 0xd51 48c7042400000000 MOVQ $0x0, 0(SP)
main.go:64 0xd59 0f57c0 XORPS X0, X0
main.go:64 0xd5c 0f11442408 MOVUPS X0, 0x8(SP)
main.go:64 0xd61 e800000000 CALL 0xd66 [1:5]R_CALL:fmt.Println
main.go:65 0xd66 488b6c2448 MOVQ 0x48(SP), BP
main.go:65 0xd6b 4883c450 ADDQ $0x50, SP
main.go:65 0xd6f c3 RET
main.go:38 0xd70 e800000000 CALL 0xd75 [1:5]R_CALL:runtime.morestack_noctxt
main.go:38 0xd75 e930ffffff JMP %22%22.main(SB)
以main.go 42行 x.VIncr(5)為例，在main里面，傳遞參數對應的指令是main.go:42 0xcd4 48c704240a000000 MOVQ $0xa, 0(SP); 將值 10 作為第一個參數
main.go:42 0xcdc 48c744240805000000 MOVQ $0x5, 0x8(SP); 將值 5 作為第二個參數
main.go:42 0xce5 e800000000 CALL 0xcea [1:5]R_CALL:%22%22.XAxis.VIncr
再看 x.VIncr 的匯編代碼：main.go:14 0xbb0 488b442408 MOVQ 0x8(SP), AX; 取第一個參數到寄存器AX
main.go:14 0xbb5 4803442410 ADDQ 0x10(SP), AX; 取第二個參數加到寄存器AX
main.go:14 0xbba 4889442408 MOVQ AX, 0x8(SP); 將和寫入到了第一個參數在棧上的位置
main.go:16 0xbbf c3 RET
可以看到，方法 VIncr 的 receiver 是值，則caller在調用VIncr的時候，將這個值復制到棧上給VIncr的參數區里，在 VIncr 對receiver的修改，實際上是修改的這個參數區里的值，而不是 caller 棧里保存局部變量的區里的 receiver 的值(在語言使用者視角，就是 修改的是拷貝而不是原值)。
接著我們看main.go第48行 x.PIncr(5)，在main里面，調用的指令是：main.go:39 0xccb 48c74424300a000000 MOVQ $0xa, 0x30(SP)
...
main.go:48 0xcea 488d442430 LEAQ 0x30(SP), AX; 將SP+0x30這個內存地址保存到AX; SP+0x30這個內存地址里存的是 10(執行 var x XAxis = 10 時定義的局部變量)
main.go:48 0xcef 48890424 MOVQ AX, 0(SP); 將AX的值作為第一個參數。
main.go:48 0xcf3 48c744240805000000 MOVQ $0x5, 0x8(SP); 將 5 作為第二個參數
main.go:48 0xcfc e800000000 CALL 0xd01 [1:5]R_CALL:%22%22.(*XAxis).PIncr
PIncr的匯編代碼：main.go:19 0xbd4 488b442408 MOVQ 0x8(SP), AX; 將第一個參數(即main的幀棧上局部變量 x 的內存地址)讀取到AX
main.go:19 0xbd9 8400 TESTB AL, 0(AX)
main.go:19 0xbdb 488b4c2408 MOVQ 0x8(SP), CX; 將第一個參數(即main的幀棧上局部變量 x 的內存地址)讀取到 CX
main.go:19 0xbe0 8401 TESTB AL, 0(CX)
main.go:19 0xbe2 488b00 MOVQ 0(AX), AX; 從 AX 里讀到內存地址，從內存地址里拿到值，再讀到AX(就是main的局部變量 x 的值)
main.go:19 0xbe5 4803442410 ADDQ 0x10(SP), AX; 將 第二個參數 5 加到 AX 里
main.go:19 0xbea 488901 MOVQ AX, 0(CX); 將計算結果寫入到 CX 里的內存地址(即 main的幀棧上局部變量 x 的內存地址)
main.go:21 0xbed c3 RET
可以看到，方法 PIncr 的 receiver 是指針(pointer)，則caller在調用PIncr的時候，將這個pointer復制到棧上給PIncr的參數區里，在 PIncr 對receiver的修改，實際上是修改pointer指向的內存區域，也就是main的局部變量 x。(在語言使用者視角，就是 修改的是原值)。
打印調用棧，相比匯編更方便的看實際傳遞的參數：goroutine 1 [running]:
runtime/debug.Stack(0x1036126, 0x10a4360, 0xc000098000)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.XAxis.VIncr(0xa, 0x5)
/Users/user/go/src/test/main.go:18 +0x26
main.main()
/Users/user/go/src/test/main.go:47 +0x40
goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.(*XAxis).PIncr(0xc000080f70, 0x5)
/Users/user/go/src/test/main.go:24 +0x33
main.main()
/Users/user/go/src/test/main.go:53 +0x57
goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.Point.VScale(0x2, 0x2, 0x5)
/Users/user/go/src/test/main.go:31 +0x26
main.main()
/Users/user/go/src/test/main.go:61 +0x90
goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.(*Point).PScale(0xc000080f78, 0x5)
/Users/user/go/src/test/main.go:39 +0x46
main.main()
/Users/user/go/src/test/main.go:67 +0xa7
當方法的receiver是value的時候，調用方法時是把value拷貝一份作為第一個參數傳遞給callee的，這樣caller里對receiver的修改實際上是修改的拷貝，不影響原值。當方法的receiver是pointer的時候，調用方法時是把pointer拷貝一份作為第一個參數傳遞給caller的，這樣callee可以通過這個pointer修改原值。
一點補充如果在方法里修改receiver的值要對caller生效，使用 pointer receiver
出于性能優化，如果receiver是結構體或者數組這樣占用較多內存的數據類型，優先使用pointer receiver
注意：值接收器是并發安全的，而指針接收器不是并發安全的。
調用規則：類型 T 的可調用方法集包含接受者為T 或 T 的所有方法集
類型 T 的可調用方法集包含接受者為 T 的所有方法
類型 T 的可調用方法集不包含接受者為 *T 的方法
方法的接收者與函數/方法的參數的比較：函數/方法的實參類型和形參類型必須一致，(在語法上)不能一個是pointer而另一個是value。
方法的接收者比較智能，如果是 pointer receiver，在值上也可以調用這個方法(編譯器會自動插入從值取到指針的指令)。如果是 value receiver，那么當在pointer上調用這個方法時，編譯器會自動將pointer轉換為pointer所對應的值。
匿名函數和閉包
匿名函數
匿名函數由一個不帶函數名的函數聲明和函數體組成，匿名函數可以賦值給變量，作為結構體字段，或者在channel中傳遞。在底層實現中，實際上傳遞的是匿名函數的入口地址。package main
func test() func(int) int {
return func(x int) int {
x += x
return x
}
}
func main() {
f := test()
f(100)
}TEXT %22%22.test(SB) gofile../Users/user/go/src/test/main.go
main.go:4 0x4e7 48c744240800000000 MOVQ $0x0, 0x8(SP)
main.go:5 0x4f0 488d0500000000 LEAQ 0(IP), AX [3:7]R_PCREL:%22%22.test.func1·f
main.go:5 0x4f7 4889442408 MOVQ AX, 0x8(SP)
main.go:5 0x4fc c3 RET
TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
main.go:11 0x517 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE
main.go:11 0x520 483b6110 CMPQ 0x10(CX), SP
main.go:11 0x524 7633 JBE 0x559
main.go:11 0x526 4883ec20 SUBQ $0x20, SP
main.go:11 0x52a 48896c2418 MOVQ BP, 0x18(SP)
main.go:11 0x52f 488d6c2418 LEAQ 0x18(SP), BP
main.go:12 0x534 e800000000 CALL 0x539 [1:5]R_CALL:%22%22.test
main.go:12 0x539 488b1424 MOVQ 0(SP), DX
main.go:12 0x53d 4889542410 MOVQ DX, 0x10(SP)
main.go:13 0x542 48c7042464000000 MOVQ $0x64, 0(SP)
main.go:13 0x54a 488b02 MOVQ 0(DX), AX
main.go:13 0x54d ffd0 CALL AX [0:0]R_CALLIND
main.go:14 0x54f 488b6c2418 MOVQ 0x18(SP), BP
main.go:14 0x554 4883c420 ADDQ $0x20, SP
main.go:14 0x558 c3 RET
main.go:11 0x559 e800000000 CALL 0x55e [1:5]R_CALL:runtime.morestack_noctxt
main.go:11 0x55e ebb7 JMP %22%22.main(SB)
TEXT %22%22.test.func1(SB) gofile../Users/user/go/src/test/main.go
main.go:5 0x58a 48c744241000000000 MOVQ $0x0, 0x10(SP)
main.go:6 0x593 488b442408 MOVQ 0x8(SP), AX
main.go:6 0x598 4803442408 ADDQ 0x8(SP), AX
main.go:6 0x59d 4889442408 MOVQ AX, 0x8(SP)
main.go:7 0x5a2 4889442410 MOVQ AX, 0x10(SP)
閉包
當函數引用外部作用域的變量時，我們稱之為閉包。在底層實現上，閉包由函數地址和引用到的變量的地址組成，并存儲在一個結構體里，在閉包被傳遞時，實際是該結構體的地址被傳遞。因為棧幀上的值在該幀的函數退出后就失效了，因此閉包引用的外部作用域的變量會被分配到堆上。在以下的實現中，test()函數返回一個閉包賦值給f，實際是main里收到閉包結構體(堆上)的地址，并保存在DX寄存器上，地址對應的內存值是閉包函數地址(函數地址取到寄存器之后，就可以通過 call 調用)，地址偏移8個字節(+8bytes)是變量x的的地址，在main里調用閉包函數f時，f內部依然是通過讀取DX的值來得到變量x的地址。即main調用f雖然沒有傳遞參數也沒有返回值，但是他們卻共享了一個寄存器DX的值。
package main
func test() func() {
x := 100
return func() {
x += 100
}
}
func main() {
f := test()
f()
f()
f()
}TEXT %22%22.test(SB) gofile../Users/user/go/src/test/main.go
main.go:3 0x6ad 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE
main.go:3 0x6b6 483b6110 CMPQ 0x10(CX), SP
main.go:3 0x6ba 0f869b000000 JBE 0x75b
main.go:3 0x6c0 4883ec28 SUBQ $0x28, SP
main.go:3 0x6c4 48896c2420 MOVQ BP, 0x20(SP)
main.go:3 0x6c9 488d6c2420 LEAQ 0x20(SP), BP
main.go:3 0x6ce 48c744243000000000 MOVQ $0x0, 0x30(SP)
main.go:4 0x6d7 488d0500000000 LEAQ 0(IP), AX [3:7]R_PCREL:type.int
main.go:4 0x6de 48890424 MOVQ AX, 0(SP)
main.go:4 0x6e2 e800000000 CALL 0x6e7 [1:5]R_CALL:runtime.newobject
main.go:4 0x6e7 488b442408 MOVQ 0x8(SP), AX
main.go:4 0x6ec 4889442418 MOVQ AX, 0x18(SP)
main.go:4 0x6f1 48c70064000000 MOVQ $0x64, 0(AX)
main.go:5 0x6f8 488d0500000000 LEAQ 0(IP), AX [3:7]R_PCREL:type.noalg.struct { F uintptr; %22%22.x *int }
main.go:5 0x6ff 48890424 MOVQ AX, 0(SP)
main.go:5 0x703 e800000000 CALL 0x708 [1:5]R_CALL:runtime.newobject
main.go:5 0x708 488b442408 MOVQ 0x8(SP), AX
main.go:5 0x70d 4889442410 MOVQ AX, 0x10(SP)
main.go:5 0x712 488d0d00000000 LEAQ 0(IP), CX [3:7]R_PCREL:%22%22.test.func1
main.go:5 0x719 488908 MOVQ CX, 0(AX)
main.go:5 0x71c 488b442410 MOVQ 0x10(SP), AX
main.go:5 0x721 8400 TESTB AL, 0(AX)
main.go:5 0x723 488b4c2418 MOVQ 0x18(SP), CX
main.go:5 0x728 488d7808 LEAQ 0x8(AX), DI
main.go:5 0x72c 833d0000000000 CMPL $0x0, 0(IP) [2:6]R_PCREL:runtime.writeBarrier+-1
main.go:5 0x733 7402 JE 0x737
main.go:5 0x735 eb1a JMP 0x751
main.go:5 0x737 48894808 MOVQ CX, 0x8(AX)
main.go:5 0x73b eb00 JMP 0x73d
main.go:5 0x73d 488b442410 MOVQ 0x10(SP), AX
main.go:5 0x742 4889442430 MOVQ AX, 0x30(SP)
main.go:5 0x747 488b6c2420 MOVQ 0x20(SP), BP
main.go:5 0x74c 4883c428 ADDQ $0x28, SP
main.go:5 0x750 c3 RET
main.go:5 0x751 4889c8 MOVQ CX, AX
main.go:5 0x754 e800000000 CALL 0x759 [1:5]R_CALL:runtime.gcWriteBarrier
main.go:5 0x759 ebe2 JMP 0x73d
main.go:3 0x75b e800000000 CALL 0x760 [1:5]R_CALL:runtime.morestack_noctxt
main.go:3 0x760 e948ffffff JMP %22%22.test(SB)
TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
main.go:10 0x7bc 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE
main.go:10 0x7c5 483b6110 CMPQ 0x10(CX), SP
main.go:10 0x7c9 763f JBE 0x80a
main.go:10 0x7cb 4883ec18 SUBQ $0x18, SP
main.go:10 0x7cf 48896c2410 MOVQ BP, 0x10(SP)
main.go:10 0x7d4 488d6c2410 LEAQ 0x10(SP), BP
main.go:11 0x7d9 e800000000 CALL 0x7de [1:5]R_CALL:%22%22.test
main.go:11 0x7de 488b1424 MOVQ 0(SP), DX
main.go:11 0x7e2 4889542408 MOVQ DX, 0x8(SP)
main.go:12 0x7e7 488b02 MOVQ 0(DX), AX
main.go:12 0x7ea ffd0 CALL AX [0:0]R_CALLIND
main.go:13 0x7ec 488b542408 MOVQ 0x8(SP), DX
main.go:13 0x7f1 488b02 MOVQ 0(DX), AX
main.go:13 0x7f4 ffd0 CALL AX [0:0]R_CALLIND
main.go:14 0x7f6 488b542408 MOVQ 0x8(SP), DX
main.go:14 0x7fb 488b02 MOVQ 0(DX), AX
main.go:14 0x7fe ffd0 CALL AX [0:0]R_CALLIND
main.go:15 0x800 488b6c2410 MOVQ 0x10(SP), BP
main.go:15 0x805 4883c418 ADDQ $0x18, SP
main.go:15 0x809 c3 RET
main.go:10 0x80a e800000000 CALL 0x80f [1:5]R_CALL:runtime.morestack_noctxt
main.go:10 0x80f ebab JMP %22%22.main(SB)
TEXT %22%22.test.func1(SB) gofile../Users/user/go/src/test/main.go
main.go:5 0x84b 4883ec10 SUBQ $0x10, SP
main.go:5 0x84f 48896c2408 MOVQ BP, 0x8(SP)
main.go:5 0x854 488d6c2408 LEAQ 0x8(SP), BP
main.go:5 0x859 488b4208 MOVQ 0x8(DX), AX
main.go:5 0x85d 48890424 MOVQ AX, 0(SP)
main.go:6 0x861 48830064 ADDQ $0x64, 0(AX)
main.go:7 0x865 488b6c2408 MOVQ 0x8(SP), BP
main.go:7 0x86a 4883c410 ADDQ $0x10, SP
main.go:7 0x86e c3 RET
遞歸函數
從本質上講遞歸函數與普通函數并無特殊之處，只是不斷調用自身，棧不斷增加而已。在 C 里面棧大小是固定的，因此需要關心棧溢出(Stack overflow)的問題。不過 Go 里面棧根據需要自動擴容，不需要擔心這個問題。
關于 defer 語句
defer與return
可以先看一下下面三個函數，嘗試推理函數的返回值：func f() (result int) {
defer func() {
result++
}()
return 0
}
func f() (r int) {
t := 5
defer func() {
t = t + 5
}()
return t
}
func f() (r int) {
defer func(r int) {
r = r + 5
}(r)
return 1
}
正確答案分別是：1，5，1。如果你的答案正確，可以略過下面的解釋了 :)
"defer 后的函數調用 在 return 語句之前執行"這句話并不容易理解正確。實際上 return xxx 語句不是原子的，而是先將xxx寫入到 caller 為返回值分配的棧空間，接著執行 RET 指令這兩步操作。defer函數就是插入在 RET 指令前執行。goroutine的控制結構里有一張記錄defer表達式的表，編譯器在defer出現的地方插入了指令 call runtime.deferproc，它將defer的表達式記錄在表中。然后在函數返回之前依次從defer表中將表達式出棧執行，這時插入的指令是call runtime.deferreturn。
defer 與閉包
defer 語句調用的函數的參數是在defer注冊時求值或復制的。因此局部變量作為參數傳遞給defer的函數語句后，后面對局部變量的修改將不再影響defer函數內對該變量值的使用。但是defer函數里使用非參數傳入的外部函數的變量，將使用到該變量在外部函數生命周期內最終的值。package main
import "fmt"
func test() {
x, y := 10, 20
defer func(i int) {
fmt.Println("defer:", i, y)
}(x)
x += 10
y += 100
fmt.Println(x, y)
}
func main(){
test()
}輸出：
20 120
defer: 10 120
備注：內存中棧從高地址空間向低地址空間增長，棧頂比棧底的內存地址小，分配棧空間對應的是 sp 值的減小。
寫值是從低地址往高地址寫，比如 SP 指向 0xff00，往棧里寫入一個字(8 字節)，占用的是 0xff00 到 0xff07 這 8 個字節。
intel存儲字節的順序為小端優先：即低有效字節存儲在內存低地址中。
在IA-32和X86-64中，字長定義為16位，dword(雙倍字)是 32 位，qword(四倍字)是64位。
生成匯編文件的方法使用 go tool compile -N -l -S go_file.go 生成
使用 go tool compile -N -l go_file.go編譯成二進制文件，接著執行 go tool objdump bin_name.o反匯編出代碼，可以通過 -s 指定函數名從而只反匯編特定函數：go tool objdump -s YOUR_FUNC_NAME bin_name.o
使用 go build -gcflags -S生成
注意：go tool compile 和 go build -gcflags -S 生成的是過程中的匯編，go tool objdump生成的是最終的機器碼的匯編。
總結
Go 語言完全使用棧來傳遞參數和返回值并由調用者負責清棧，通過棧傳遞返回值使得Go函數能支持多返回值，調用者清棧則可以實現可變參數的函數。Go 使用值傳遞的模式傳遞參數，因此傳遞數組和結構體時，應該盡量使用指針作為參數來避免大量數據拷貝從而提升性能。
Go 方法調用的時候是將接收者作為參數傳遞給了callee，接收者分值接收者和指針接收者。
當傳遞匿名函數的時候，傳遞的實際上是函數的入口指針。當使用閉包的時候，Go 通過逃逸分析機制將變量分配到堆內存，變量地址和函數入口地址組成一個存在堆上的結構體，傳遞閉包的時候，傳遞的就是這個結構體的地址。
Go 的數據類型分為值類型和引用類型，但 Go 的參數傳遞是值傳遞。當傳遞的是值類型的時候，是完全的拷貝，callee里對參數的修改不影響原值；當傳遞的是引用類型的時候，callee里的修改會影響原值。
帶返回值的return語句對應的是多條機器指令，首先是將返回值寫入到caller在棧上為返回值分配的空間，然后執行ret指令。有defer語句的時候，defer語句里的函數就是插入到 ret 指令之前執行。
參考和深入閱讀：
本文從這些文章中引用了代碼樣例和語句
查看原文
總結
以上是生活随笔為你收集整理的bmf mysql_bmf 的动态 - SegmentFault 思否的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 超长数列中n个整数排序C++代码实现
- 下一篇： 求指定范围内的所有素数C++代码实现