碼上歡樂
相關內容    簡體    繁體

深度解密Go語言之Slice

本文轉載自   查看原文   2019-04-01 22:23   4436    Golang

Go 語言的 slice 很好用，不過也有一些坑。slice 是 Go 語言一個很重要的數據結構。網上已經有很多文章寫過了，似乎沒必要再寫。但是每個人看問題的視角不同，寫出來的東西自然也不一樣。我這篇會從更底層的匯編語言去解讀它。而且在我寫這篇文章的過程中，發現絕大部分文章都存在一些問題，文章里會講到，這里先不展開。

我希望本文可以終結這個話題，下次再有人想和你討論 slice，直接把這篇文章的鏈接丟過去就行了。

目錄

當我們在說 slice 時，到底在說什么

slice 翻譯成中文就是切片，它和數組（array）很類似，可以用下標的方式進行訪問，如果越界，就會產生 panic。但是它比數組更靈活，可以自動地進行擴容。

了解 slice 的本質，最簡單的方法就是看它的源代碼：

// runtime/slice.go
type slice struct {
	array unsafe.Pointer // 元素指針
	len   int // 長度 
	cap   int // 容量
}

看到了嗎，slice 共有三個屬性：
指針，指向底層數組；
長度，表示切片可用元素的個數，也就是說使用下標對 slice 的元素進行訪問時，下標不能超過 slice 的長度；
容量，底層數組的元素個數，容量 >= 長度。在底層數組不進行擴容的情況下，容量也是 slice 可以擴張的最大限度。

切片數據結構

注意，底層數組是可以被多個 slice 同時指向的，因此對一個 slice 的元素進行操作是有可能影響到其他 slice 的。

slice 的創建

創建 slice 的方式有以下幾種：

序號 方式 代碼示例
1 直接聲明 var slice []int
2 new slice := *new([]int)
3 字面量 slice := []int{1,2,3,4,5}
4 make slice := make([]int, 5, 10)
5 從切片或數組“截取” slice := array[1:5] 或 slice := sourceSlice[1:5]

直接聲明

第一種創建出來的 slice 其實是一個 nil slice。它的長度和容量都為0。和nil比較的結果為true。

這里比較混淆的是empty slice，它的長度和容量也都為0，但是所有的空切片的數據指針都指向同一個地址 0xc42003bda0。空切片和 nil 比較的結果為false。

它們的內部結構如下圖：

nil slice 與 empty slice

創建方式 nil切片 空切片
方式一 var s1 []int var s2 = []int{}
方式二 var s4 = *new([]int) var s3 = make([]int, 0)
長度 0 0
容量 0 0
和 nil 比較 true false

nil 切片和空切片很相似，長度和容量都是0，官方建議盡量使用 nil 切片。

關於nil slice和empty slice的探索可以參考公眾號“碼洞”作者老錢寫的一篇文章《深度解析 Go 語言中「切片」的三種特殊狀態》，地址附在了參考資料部分。

字面量

比較簡單，直接用初始化表達式創建。

package main

import "fmt"

func main() {
	s1 := []int{0, 1, 2, 3, 8: 100}
	fmt.Println(s1, len(s1), cap(s1))
}

運行結果：

[0 1 2 3 0 0 0 0 100] 9 9

唯一值得注意的是上面的代碼例子中使用了索引號，直接賦值，這樣，其他未注明的元素則默認 0 值。

make

make函數需要傳入三個參數：切片類型，長度，容量。當然，容量可以不傳，默認和長度相等。

上篇文章《走進Go的底層》中，我們學到了匯編這個工具，這次我們再次請出匯編來更深入地看看slice。如果沒看過上篇文章，建議先回去看完，再繼續閱讀本文效果更佳。

先來一小段玩具代碼，使用 make 關鍵字創建 slice：

package main

import "fmt"

func main() {
	slice := make([]int, 5, 10) // 長度為5，容量為10
	slice[2] = 2 // 索引為2的元素賦值為2
	fmt.Println(slice)
}

執行如下命令，得到 Go 匯編代碼：

go tool compile -S main.go

我們只關注main函數：

0x0000 00000 (main.go:5)TEXT    "".main(SB), $96-0
0x0000 00000 (main.go:5)MOVQ    (TLS), CX
0x0009 00009 (main.go:5)CMPQ    SP, 16(CX)
0x000d 00013 (main.go:5)JLS     228
0x0013 00019 (main.go:5)SUBQ    $96, SP
0x0017 00023 (main.go:5)MOVQ    BP, 88(SP)
0x001c 00028 (main.go:5)LEAQ    88(SP), BP
0x0021 00033 (main.go:5)FUNCDATA    $0, gclocals·69c1753bd5f81501d95132d08af04464(SB)
0x0021 00033 (main.go:5)FUNCDATA    $1, gclocals·57cc5e9a024203768cbab1c731570886(SB)
0x0021 00033 (main.go:5)LEAQ    type.int(SB), AX
0x0028 00040 (main.go:6)MOVQ    AX, (SP)
0x002c 00044 (main.go:6)MOVQ    $5, 8(SP)
0x0035 00053 (main.go:6)MOVQ    $10, 16(SP)
0x003e 00062 (main.go:6)PCDATA  $0, $0
0x003e 00062 (main.go:6)CALL    runtime.makeslice(SB)
0x0043 00067 (main.go:6)MOVQ    24(SP), AX
0x0048 00072 (main.go:6)MOVQ    32(SP), CX
0x004d 00077 (main.go:6)MOVQ    40(SP), DX
0x0052 00082 (main.go:7)CMPQ    CX, $2
0x0056 00086 (main.go:7)JLS     221
0x005c 00092 (main.go:7)MOVQ    $2, 16(AX)
0x0064 00100 (main.go:8)MOVQ    AX, ""..autotmp_2+64(SP)
0x0069 00105 (main.go:8)MOVQ    CX, ""..autotmp_2+72(SP)
0x006e 00110 (main.go:8)MOVQ    DX, ""..autotmp_2+80(SP)
0x0073 00115 (main.go:8)MOVQ    $0, ""..autotmp_1+48(SP)
0x007c 00124 (main.go:8)MOVQ    $0, ""..autotmp_1+56(SP)
0x0085 00133 (main.go:8)LEAQ    type.[]int(SB), AX
0x008c 00140 (main.go:8)MOVQ    AX, (SP)
0x0090 00144 (main.go:8)LEAQ    ""..autotmp_2+64(SP), AX
0x0095 00149 (main.go:8)MOVQ    AX, 8(SP)
0x009a 00154 (main.go:8)PCDATA  $0, $1
0x009a 00154 (main.go:8)CALL    runtime.convT2Eslice(SB)
0x009f 00159 (main.go:8)MOVQ    16(SP), AX
0x00a4 00164 (main.go:8)MOVQ    24(SP), CX
0x00a9 00169 (main.go:8)MOVQ    AX, ""..autotmp_1+48(SP)
0x00ae 00174 (main.go:8)MOVQ    CX, ""..autotmp_1+56(SP)
0x00b3 00179 (main.go:8)LEAQ    ""..autotmp_1+48(SP), AX
0x00b8 00184 (main.go:8)MOVQ    AX, (SP)
0x00bc 00188 (main.go:8)MOVQ    $1, 8(SP)
0x00c5 00197 (main.go:8)MOVQ    $1, 16(SP)
0x00ce 00206 (main.go:8)PCDATA  $0, $1
0x00ce 00206 (main.go:8)CALL    fmt.Println(SB)
0x00d3 00211 (main.go:9)MOVQ    88(SP), BP
0x00d8 00216 (main.go:9)ADDQ    $96, SP
0x00dc 00220 (main.go:9)RET
0x00dd 00221 (main.go:7)PCDATA  $0, $0
0x00dd 00221 (main.go:7)CALL    runtime.panicindex(SB)
0x00e2 00226 (main.go:7)UNDEF
0x00e4 00228 (main.go:7)NOP
0x00e4 00228 (main.go:5)PCDATA  $0, $-1
0x00e4 00228 (main.go:5)CALL    runtime.morestack_noctxt(SB)
0x00e9 00233 (main.go:5)JMP     0

先說明一下，Go 語言匯編 FUNCDATA 和 PCDATA 是編譯器產生的，用於保存一些和垃圾收集相關的信息，我們先不用 care。

以上匯編代碼行數比較多，沒關系，因為命令都比較簡單，而且我們的 Go 源碼也足夠簡單，沒有理由看不明白。

我們先從上到下掃一眼，看到幾個關鍵函數：

CALL    runtime.makeslice(SB)
CALL    runtime.convT2Eslice(SB)
CALL    fmt.Println(SB)
CALL    runtime.morestack_noctxt(SB)
序號 功能
1 創建slice
2 類型轉換
3 打印函數
4 棧空間擴容

1是創建 slice 相關的；2是類型轉換；調用 fmt.Println需要將 slice 作一個轉換； 3是打印語句；4是棧空間擴容函數，在函數開始處，會檢查當前棧空間是否足夠，不夠的話需要調用它來進行擴容。暫時可以忽略。

調用了函數就會涉及到參數傳遞，Go 的參數傳遞都是通過 棧空間完成的。接下來，我們詳細分析這整個過程。

行數 作用
1 main函數定義，棧幀大小為 96B
2-4 判斷棧是否需要進行擴容，如果需要則跳到 228，這里會調用 runtime.morestack_noctxt(SB) 進行棧擴容操作。具體細節后續還會有文章來講
5-9 將 caller BP 壓棧，具體細節后面會講到
10-15 調用 runtime.makeslice(SB) 函數及准備工作。*_type表示的是 int，也就是 slice 元素的類型。這里對應的源碼是第6行，也就是調用 make 創建 slice 的那一行。5 和 10 分別代表長度和容量，函數參數會在棧頂准備好，之后執行函數調用命令 CALL，進入到被調用函數的棧幀，就會按順序從 caller 的棧頂取函數參數
16-18 接收 makeslice的返回值，通過 move 移動到寄存器中
19-21 給數組索引值為 2 的元素賦上值 2，因為是 int 型的 slice，元素大小為8字節，所以 MOVQ $2, 16(AX) 此命令就是將 2 搬到索引為 2 的位置。這里還會對索引值的大小進行檢查，如果越界，則會跳轉到 221，執行 panic 函數
22-26 分別通過寄存器 AX，CX，DX 將 makeslice 的返回值 move 到內存的其他位置，也稱為局部變量，這樣就構造出了 slice

makeslice 棧幀

左邊是棧上的數據，右邊是堆上的數據。array 指向 slice 的底層數據，被分配到堆上了。注意，棧上的地址是從高向低增長；堆則從低向高增長。棧左邊的數字表示對應的匯編代碼的行數，棧右邊箭頭則表示棧地址。（48）SP、（56）SP 表示的內容接着往下看。

注意，在圖中，棧地址是從下往上增長，所以 SP 表示的是圖中 *_type 所在的位置，其它的依此類推。

行數 作用
27-32 准備調用 runtime.convT2Eslice(SB)的函數參數
33-36 接收返回值，通過AX，CX寄存器 move 到(48)SP、（56）SP

convT2Eslice 的函數聲明如下：

func convT2Eslice(t *_type, elem unsafe.Pointer) (e eface)

第一個參數是指針 *_type，_type是一個表示類型的結構體，這里傳入的就是 slice的類型 []int；第二個參數則是元素的指針，這里傳入的就是 slice 底層數組的首地址。

返回值 eface 的結構體定義如下：

type eface struct {
	_type *_type
	data  unsafe.Pointer
}

由於我們會調用 fmt.Println(slice)，看下函數原型：

func Println(a ...interface{}) (n int, err error)

Println 接收 interface 類型，因此我們需要將 slice 轉換成 interface 類型。由於 slice 沒有方法，是個“空 interface”。因此會調用 convT2Eslice 完成這一轉換過程。

convT2Eslice 函數返回的是類型指針和數據地址。源碼就不貼了，大體流程是：調用 mallocgc 分配一塊內存，把數據 copy 進到新的內存，然后返回這塊內存的地址，*_type 則直接返回傳入的參數。

convT2Eslice 棧幀

32(SP) 和 40(SP) 其實是 makeslice 函數的返回值，這里可以忽略。

還剩 fmt.Println(slice) 最后一個函數調用了，我們繼續。

行數 作用
37-40 准備 Println 函數參數。共3個參數，第一個是類型地址，還有兩個 1，這塊暫時還不知道為什么要傳，有了解的同學可以在文章后面留言

所以調用 fmt.Println(slice) 時，實際是傳入了一個 slice類型的eface地址。這樣，Println就可以訪問類型中的數據，最終給“打印”出來。

fmt.Println 棧幀

最后，我們看下 main 函數棧幀的開始和收尾部分。

0x0013 00019 (main.go:5)SUBQ    $96, SP
0x0017 00023 (main.go:5)MOVQ    BP, 88(SP)
0x001c 00028 (main.go:5)LEAQ    88(SP), BP
…………………………
0x00d3 00211 (main.go:9)MOVQ    88(SP), BP
0x00d8 00216 (main.go:9)ADDQ    $96, SP
RET

BP可以理解為保存了當前函數棧幀棧底的地址，SP則保存棧頂的地址。

初始，BP 和 SP 分別有一個初始狀態。

main 函數執行的時候，先根據 main 函數棧幀大小確定 SP 的新指向，使得 main 函數棧幀大小達到 96B。之后把老的 BP 保存到 main 函數棧幀的底部，並使 BP 寄存器重新指向新的棧底，也就是 main 函數棧幀的棧底。

最后，當 main 函數執行完畢，把它棧底的 BP 給回彈回到 BP 寄存器，恢復調用前的初始狀態。一切都像是沒有發生一樣，完美的現場。

棧幀變化

這部分，又詳細地分析了一遍函數調用的過程。一方面，讓大家復習一下上一篇文章講的內容；另一方面，向大家展示如何找到 Go 中的一個函數背后真實調用了哪些函數。像例子中，我們就看到了 make 函數背后，實際上是調用了 makeslice 函數；還有一點，讓大家對匯編不那么“懼怕”，可以輕松地分析一些東西。

截取

截取也是比較常見的一種創建 slice 的方法，可以從數組或者 slice 直接截取，當然需要指定起止索引位置。

基於已有 slice 創建新 slice 對象，被稱為 reslice。新 slice 和老 slice 共用底層數組，新老 slice 對底層數組的更改都會影響到彼此。基於數組創建的新 slice 對象也是同樣的效果：對數組或 slice 元素作的更改都會影響到彼此。

值得注意的是，新老 slice 或者新 slice 老數組互相影響的前提是兩者共用底層數組，如果因為執行 append 操作使得新 slice 底層數組擴容，移動到了新的位置，兩者就不會相互影響了。所以，問題的關鍵在於兩者是否會共用底層數組。

截取操作采用如下方式：

 data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 slice := data[2:4:6] // data[low, high, max]

對 data 使用3個索引值，截取出新的 slice。這里 data 可以是數組或者 slice。low 是最低索引值，這里是閉區間，也就是說第一個元素是 data 位於 low 索引處的元素；而 high 和 max 則是開區間，表示最后一個元素只能是索引 high-1 處的元素，而最大容量則只能是索引 max-1 處的元素。

max >= high >= low

當 high == low 時，新 slice 為空。

還有一點，high 和 max 必須在老數組或者老 slice 的容量（cap）范圍內。

來看一個例子，來自雨痕大佬《Go學習筆記》第四版，P43頁，參考資料里有開源書籍地址。這里我會進行擴展，並會作詳細說明：

package main

import "fmt"

func main() {
	slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	s1 := slice[2:5]
	s2 := s1[2:6:7]

	s2 = append(s2, 100)
	s2 = append(s2, 200)

	s1[2] = 20

	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(slice)
}

先看下代碼運行的結果：

[2 3 20]
[4 5 6 7 100 200]
[0 1 2 3 20 5 6 7 100 9]

我們來走一遍代碼，初始狀態如下：

slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := slice[2:5]
s2 := s1[2:6:7]

s1 從 slice 索引2（閉區間）到索引5（開區間，元素真正取到索引4），長度為3，容量默認到數組結尾，為8。
s2 從 s1 的索引2（閉區間）到索引6（開區間，元素真正取到索引5），容量到索引7（開區間，真正到索引6），為5。

slice origin

接着，向 s2 尾部追加一個元素 100：

s2 = append(s2, 100)

s2 容量剛好夠，直接追加。不過，這會修改原始數組對應位置的元素。這一改動，數組和 s1 都可以看得到。

append 100

再次向 s2 追加元素200：

s2 = append(s2, 100)

這時，s2 的容量不夠用，該擴容了。於是，s2 另起爐灶，將原來的元素復制新的位置，擴大自己的容量。並且為了應對未來可能的 append 帶來的再一次擴容，s2 會在此次擴容的時候多留一些 buffer，將新的容量將擴大為原始容量的2倍，也就是10了。

append 200

最后，修改 s1 索引為2位置的元素：

s1[2] = 20

這次只會影響原始數組相應位置的元素。它影響不到 s2 了，人家已經遠走高飛了。

s1[2]=20

再提一點，打印 s1 的時候，只會打印出 s1 長度以內的元素。所以，只會打印出3個元素，雖然它的底層數組不止3個元素。

至於，我們想在匯編層面看看到底它們是如何共享底層數組的，限於篇幅，這里不再展開。感興趣的同學可以在公眾號后台回復：切片截取。

我會給你詳細分析函數調用關系，對共享底層數組的行為也會一目了然。二維碼見文章底部。

slice 和數組的區別在哪

slice 的底層數據是數組，slice 是對數組的封裝，它描述一個數組的片段。兩者都可以通過下標來訪問單個元素。

數組是定長的，長度定義好之后，不能再更改。在 Go 中，數組是不常見的，因為其長度是類型的一部分，限制了它的表達能力，比如 [3]int 和 [4]int 就是不同的類型。

而切片則非常靈活，它可以動態地擴容。切片的類型和長度無關。

append 到底做了什么

先來看看 append 函數的原型：

func append(slice []Type, elems ...Type) []Type

append 函數的參數長度可變，因此可以追加多個值到 slice 中，還可以用 ... 傳入 slice，直接追加一個切片。

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)

append函數返回值是一個新的slice，Go編譯器不允許調用了 append 函數后不使用返回值。

append(slice, elem1, elem2)
append(slice, anotherSlice...)

所以上面的用法是錯的，不能編譯通過。

使用 append 可以向 slice 追加元素，實際上是往底層數組添加元素。但是底層數組的長度是固定的，如果索引 len-1 所指向的元素已經是底層數組的最后一個元素，就沒法再添加了。

這時，slice 會遷移到新的內存位置，新底層數組的長度也會增加，這樣就可以放置新增的元素。同時，為了應對未來可能再次發生的 append 操作，新的底層數組的長度，也就是新 slice 的容量是留了一定的 buffer 的。否則，每次添加元素的時候，都會發生遷移，成本太高。

新 slice 預留的 buffer 大小是有一定規律的。網上大多數的文章都是這樣描述的：

當原 slice 容量小於 1024 的時候，新 slice 容量變成原來的 2 倍；原 slice 容量超過 1024，新 slice 容量變成原來的1.25倍。

我在這里先說結論：以上描述是錯誤的。

為了說明上面的規律是錯誤的，我寫了一小段玩具代碼：

package main

import "fmt"

func main() {
	s := make([]int, 0)

	oldCap := cap(s)

	for i := 0; i < 2048; i++ {
		s = append(s, i)

		newCap := cap(s)

		if newCap != oldCap {
			fmt.Printf("[%d -> %4d] cap = %-4d  |  after append %-4d  cap = %-4d\n", 0, i-1, oldCap, i, newCap)
			oldCap = newCap
		}
	}
}

我先創建了一個空的 slice，然后，在一個循環里不斷往里面 append 新的元素。然后記錄容量的變化，並且每當容量發生變化的時候，記錄下老的容量，以及添加完元素之后的容量，同時記下此時 slice 里的元素。這樣，我就可以觀察，新老 slice 的容量變化情況，從而找出規律。

運行結果：

[0 ->   -1] cap = 0     |  after append 0     cap = 1   
[0 ->    0] cap = 1     |  after append 1     cap = 2   
[0 ->    1] cap = 2     |  after append 2     cap = 4   
[0 ->    3] cap = 4     |  after append 4     cap = 8   
[0 ->    7] cap = 8     |  after append 8     cap = 16  
[0 ->   15] cap = 16    |  after append 16    cap = 32  
[0 ->   31] cap = 32    |  after append 32    cap = 64  
[0 ->   63] cap = 64    |  after append 64    cap = 128 
[0 ->  127] cap = 128   |  after append 128   cap = 256 
[0 ->  255] cap = 256   |  after append 256   cap = 512 
[0 ->  511] cap = 512   |  after append 512   cap = 1024
[0 -> 1023] cap = 1024  |  after append 1024  cap = 1280
[0 -> 1279] cap = 1280  |  after append 1280  cap = 1696
[0 -> 1695] cap = 1696  |  after append 1696  cap = 2304

在老 slice 容量小於1024的時候，新 slice 的容量的確是老 slice 的2倍。目前還算正確。

但是，當老 slice 容量大於等於 1024 的時候，情況就有變化了。當向 slice 中添加元素 1280 的時候，老 slice 的容量為 1280，之后變成了 1696，兩者並不是 1.25 倍的關系（1696/1280=1.325）。添加完 1696 后，新的容量 2304 當然也不是 1696 的 1.25 倍。

可見，現在網上各種文章中的擴容策略並不正確。我們直接搬出源碼：源碼面前，了無秘密。

從前面匯編代碼我們也看到了，向 slice 追加元素的時候，若容量不夠，會調用 growslice 函數，所以我們直接看它的代碼。

// go 1.9.5 src/runtime/slice.go:82
func growslice(et *_type, old slice, cap int) slice {
    // ……
    newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		if old.len < 1024 {
			newcap = doublecap
		} else {
			for newcap < cap {
				newcap += newcap / 4
			}
		}
	}
	// ……
	
	capmem = roundupsize(uintptr(newcap) * ptrSize)
	newcap = int(capmem / ptrSize)
}

看到了嗎？如果只看前半部分，現在網上各種文章里說的 newcap 的規律是對的。現實是，后半部分還對 newcap 作了一個內存對齊，這個和內存分配策略相關。進行內存對齊之后，新 slice 的容量是要 大於等於 老 slice 容量的 2倍或者1.25倍。

之后，向 Go 內存管理器申請內存，將老 slice 中的數據復制過去，並且將 append 的元素添加到新的底層數組中。

最后，向 growslice 函數調用者返回一個新的 slice，這個 slice 的長度並沒有變化，而容量卻增大了。

關於 append，我們最后來看一個例子，來源於參考資料部分的【Golang Slice的擴容規則】。

package main

import "fmt"

func main() {
	s := []int{1,2}
	s = append(s,4,5,6)
	fmt.Printf("len=%d, cap=%d",len(s),cap(s))
}

運行結果是：

len=5, cap=6

如果按網上各種文章中總結的那樣：小於原 slice 長度小於 1024 的時候，容量每次增加 1 倍。添加元素 4 的時候，容量變為4；添加元素 5 的時候不變；添加元素 6 的時候容量增加 1 倍，變成 8。

那上面代碼的運行結果就是：

len=5, cap=8

這是錯誤的！我們來仔細看看，為什么會這樣，再次搬出代碼：

// go 1.9.5 src/runtime/slice.go:82
func growslice(et *_type, old slice, cap int) slice {
    // ……
    newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		// ……
	}
	// ……
	
	capmem = roundupsize(uintptr(newcap) * ptrSize)
	newcap = int(capmem / ptrSize)
}

這個函數的參數依次是 元素的類型，老的 slice，新 slice 最小求的容量。

例子中 s 原來只有 2 個元素，len 和 cap 都為 2，append 了三個元素后，長度變為 3，容量最小要變成 5，即調用 growslice 函數時，傳入的第三個參數應該為 5。即 cap=5。而一方面，doublecap 是原 slice容量的 2 倍，等於 4。滿足第一個 if 條件，所以 newcap 變成了 5。

接着調用了 roundupsize 函數，傳入 40。（代碼中ptrSize是指一個指針的大小，在64位機上是8）

我們再看內存對齊，搬出 roundupsize 函數的代碼：

// src/runtime/msize.go:13
func roundupsize(size uintptr) uintptr {
	if size < _MaxSmallSize {
		if size <= smallSizeMax-8 {
			return uintptr(class_to_size[size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]])
		} else {
			//……
		}
	}
    //……
}

const _MaxSmallSize = 32768
const smallSizeMax = 1024
const smallSizeDiv = 8

很明顯，我們最終將返回這個式子的結果：

class_to_size[size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]]

這是 Go 源碼中有關內存分配的兩個 slice。class_to_size通過 spanClass獲取 span划分的 object大小。而 size_to_class8 表示通過 size 獲取它的 spanClass。

var size_to_class8 = [smallSizeMax/smallSizeDiv + 1]uint8{0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31}

var class_to_size = [_NumSizeClasses]uint16{0, 8, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896, 1024, 1152, 1280, 1408, 1536, 1792, 2048, 2304, 2688, 3072, 3200, 3456, 4096, 4864, 5376, 6144, 6528, 6784, 6912, 8192, 9472, 9728, 10240, 10880, 12288, 13568, 14336, 16384, 18432, 19072, 20480, 21760, 24576, 27264, 28672, 32768}

我們傳進去的 size 等於 40。所以 (size+smallSizeDiv-1)/smallSizeDiv = 5；獲取 size_to_class8 數組中索引為 5 的元素為 4；獲取 class_to_size 中索引為 4 的元素為 48。

最終，新的 slice 的容量為 6：

newcap = int(capmem / ptrSize) // 6

至於，上面的兩個魔法數組的由來，暫時就不展開了。

為什么 nil slice 可以直接 append

其實 nil slice 或者 empty slice 都是可以通過調用 append 函數來獲得底層數組的擴容。最終都是調用 mallocgc 來向 Go 的內存管理器申請到一塊內存，然后再賦給原來的nil slice 或 empty slice，然后搖身一變，成為“真正”的 slice 了。

傳 slice 和 slice 指針有什么區別

前面我們說到，slice 其實是一個結構體，包含了三個成員：len, cap, array。分別表示切片長度，容量，底層數據的地址。

當 slice 作為函數參數時，就是一個普通的結構體。其實很好理解：若直接傳 slice，在調用者看來，實參 slice 並不會被函數中的操作改變；若傳的是 slice 的指針，在調用者看來，是會被改變原 slice 的。

值的注意的是，不管傳的是 slice 還是 slice 指針，如果改變了 slice 底層數組的數據，會反應到實參 slice 的底層數據。為什么能改變底層數組的數據？很好理解：底層數據在 slice 結構體里是一個指針，僅管 slice 結構體自身不會被改變，也就是說底層數據地址不會被改變。 但是通過指向底層數據的指針，可以改變切片的底層數據，沒有問題。

通過 slice 的 array 字段就可以拿到數組的地址。在代碼里，是直接通過類似 s[i]=10 這種操作改變 slice 底層數組元素值。

另外，啰嗦一句，Go 語言的函數參數傳遞，只有值傳遞，沒有引用傳遞。后面會再寫一篇相關的文章，敬請期待。

再來看一個年幼無知的代碼片段：

package main

func main() {
	s := []int{1, 1, 1}
	f(s)
	fmt.Println(s)
}

func f(s []int) {
	// i只是一個副本，不能改變s中元素的值
	/*for _, i := range s {
		i++
	}
	*/

	for i := range s {
		s[i] += 1
	}
}

運行一下，程序輸出：

[2 2 2]

果真改變了原始 slice 的底層數據。這里傳遞的是一個 slice 的副本，在 f 函數中，s 只是 main 函數中 s 的一個拷貝。在f 函數內部，對 s 的作用並不會改變外層 main 函數的 s。

要想真的改變外層 slice，只有將返回的新的 slice 賦值到原始 slice，或者向函數傳遞一個指向 slice 的指針。我們再來看一個例子：

package main

import "fmt"

func myAppend(s []int) []int {
	// 這里 s 雖然改變了，但並不會影響外層函數的 s
	s = append(s, 100)
	return s
}

func myAppendPtr(s *[]int) {
	// 會改變外層 s 本身
	*s = append(*s, 100)
	return
}

func main() {
	s := []int{1, 1, 1}
	newS := myAppend(s)

	fmt.Println(s)
	fmt.Println(newS)

	s = newS

	myAppendPtr(&s)
	fmt.Println(s)
}

運行結果：

[1 1 1]
[1 1 1 100]
[1 1 1 100 100]

myAppend 函數里，雖然改變了 s，但它只是一個值傳遞，並不會影響外層的 s，因此第一行打印出來的結果仍然是 [1 1 1]。

而 newS 是一個新的 slice，它是基於 s 得到的。因此它打印的是追加了一個 100 之后的結果： [1 1 1 100]。

最后，將 newS 賦值給了 s，s 這時才真正變成了一個新的slice。之后，再給 myAppendPtr 函數傳入一個 s 指針，這回它真的被改變了：[1 1 1 100 100]。

總結

到此，關於 slice 的部分就講完了，不知大家有沒有看過癮。我們最后來總結一下：

  • 切片是對底層數組的一個抽象，描述了它的一個片段。
  • 切片實際上是一個結構體，它有三個字段：長度，容量，底層數據的地址。
  • 多個切片可能共享同一個底層數組，這種情況下，對其中一個切片或者底層數組的更改，會影響到其他切片。
  • append 函數會在切片容量不夠的情況下，調用 growslice 函數獲取所需要的內存，這稱為擴容，擴容會改變元素原來的位置。
  • 擴容策略並不是簡單的擴為原切片容量的 2 倍或 1.25 倍，還有內存對齊的操作。擴容后的容量 >= 原容量的 2 倍或 1.25 倍。
  • 當直接用切片作為函數參數時，可以改變切片的元素，不能改變切片本身；想要改變切片本身，可以將改變后的切片返回，函數調用者接收改變后的切片或者將切片指針作為函數參數。

最后，如果你覺得本文對你有幫助的話，幫我點一下右下角的“推薦”吧，感謝！

QR

參考資料

【碼洞《深度解析 Go 語言中「切片」的三種特殊狀態》】https://juejin.im/post/5bea58df6fb9a049f153bca8
【老錢 數組】https://juejin.im/post/5be53bc251882516c15af2e0
【老錢 切片】https://juejin.im/post/5be8e0b1f265da614d08b45a
【golang interface源碼】https://i6448038.github.io/2018/10/01/Golang-interface/
【golang interface源碼】http://legendtkl.com/2017/07/01/golang-interface-implement/
【interface】https://www.jishuwen.com/d/2C9z#tuit
【雨痕開源Go學習筆記】https://github.com/qyuhen/book
【slice 圖很漂亮】https://halfrost.com/go_slice/
【Golang Slice的擴容規則】https://jodezer.github.io/2017/05/golangSlice的擴容規則
【slice作為參數】https://www.cnblogs.com/fwdqxl/p/9317769.html
【源碼】https://ictar.xyz/2018/10/25/深入淺出-go-slice/
【append機制 譯文】https://brantou.github.io/2017/05/24/go-array-slice-string/
【slice 匯編】http://xargin.com/go-slice/
【slice tricks】https://colobu.com/2017/03/22/Slice-Tricks/
【有圖】https://i6448038.github.io/2018/08/11/array-and-slice-principle/
【slice的本質】https://www.flysnow.org/2018/12/21/golang-sliceheader.html
【slice使用技巧】https://blog.thinkeridea.com/201901/go/slice_de_yi_xie_shi_yong_ji_qiao.html
【slice/array、內存增長】https://blog.thinkeridea.com/201901/go/shen_ru_pou_xi_slice_he_array.html


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 深度解密Go語言之unsafe 深度解密Go語言之channel 深度解密 Go 語言之 sync.map 深度解密 Go 語言之 sync.Pool go語言中的slice Go語言之反射（一） Go語言之接口 Go語言之json Go語言之GO 語言注釋 Go語言之main包
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM