Golang切片和陣列底層詳解

切片是 Go 中的一種基本的資料結構，使用這種結構可以用來管理資料集合。切片的設計想法是由動態陣列概念而來，為了開發者可以更加方便的使一個資料結構可以自動增加和減少。但是切片本身並不是動態資料或者陣列指標。切片常見的操作有 reslice、append、copy。與此同時，切片還具有可索引，可迭代的優秀特性。

一. 切片和陣列

關於切片和陣列怎麼選擇？接下來好好討論討論這個問題。

在 Go 中，與 C 陣列變數隱式作為指標使用不同，Go 陣列是值型別，賦值和函式傳參操作都會複製整個陣列資料。

func main() {
    arrayA := [2]int{100, 200}
    var arrayB [2]int

    arrayB = arrayA

    fmt.Printf("arrayA : %p , %v\n", &arrayA, arrayA)
    fmt.Printf("arrayB : %p , %v\n", &arrayB, arrayB)

    testArray(arrayA)
}

func testArray(x [2]int) {
    fmt.Printf("func Array : %p , %v\n", &x, x)
}

列印結果：

arrayA : 0xc4200bebf0 , [100 200]
arrayB : 0xc4200bec00 , [100 200]
func Array : 0xc4200bec30 , [100 200]

可以看到，三個記憶體地址都不同，這也就驗證了 Go 中陣列賦值和函式傳參都是值複製的。那這會導致什麼問題呢？

假想每次傳參都用陣列，那麼每次陣列都要被複制一遍。如果陣列大小有 100萬，在64位機器上就需要花費大約 800W 位元組，即 8MB 記憶體。這樣會消耗掉大量的記憶體。於是乎有人想到，函式傳參用陣列的指標。

func main() {
    arrayA := [2]int{100, 200}
    testArrayPoint(&arrayA)   // 1.傳陣列指標
    arrayB := arrayA[:]
    testArrayPoint(&arrayB)   // 2.傳切片
    fmt.Printf("arrayA : %p , %v\n", &arrayA, arrayA)
}

func testArrayPoint(x *[]int) {
    fmt.Printf("func Array : %p , %v\n", x, *x)
    (*x)[1] += 100
}

列印結果：

func Array : 0xc4200b0140 , [100 200]
func Array : 0xc4200b0180 , [100 300]
arrayA : 0xc4200b0140 , [100 400]

這也就證明了陣列指標確實到達了我們想要的效果。現在就算是傳入10億的陣列，也只需要再棧上分配一個8個位元組的記憶體給指標就可以了。這樣更加高效的利用記憶體，效能也比之前的好。

不過傳指標會有一個弊端，從列印結果可以看到，第一行和第三行指標地址都是同一個，萬一原陣列的指標指向更改了，那麼函式裡面的指標指向都會跟著更改。

切片的優勢也就表現出來了。用切片傳陣列引數，既可以達到節約記憶體的目的，也可以達到合理處理好共享記憶體的問題。列印結果第二行就是切片，切片的指標和原來陣列的指標是不同的。

由此我們可以得出結論：

把第一個大陣列傳遞給函式會消耗很多記憶體，採用切片的方式傳參可以避免上述問題。切片是引用傳遞，所以它們不需要使用額外的記憶體並且比使用陣列更有效率。

但是，依舊有反例。

package main

import "testing"

func array() [1024]int {
    var x [1024]int
    for i := 0; i < len(x); i++ {
        x[i] = i
    }
    return x
}

func slice() []int {
    x := make([]int, 1024)
    for i := 0; i < len(x); i++ {
        x[i] = i
    }
    return x
}

func BenchmarkArray(b *testing.B) {
    for i := 0; i < b.N; i++ {
        array()
    }
}

func BenchmarkSlice(b *testing.B) {
    for i := 0; i < b.N; i++ {
        slice()
    }
}

我們做一次效能測試，並且禁用內聯和優化，來觀察切片的堆上記憶體分配的情況。

  go test -bench . -benchmem -gcflags "-N -l"

輸出結果比較“令人意外”：

BenchmarkArray-4          500000              3637 ns/op               0 B/op          0 alloc s/op
BenchmarkSlice-4          300000              4055 ns/op            8192 B/op          1 alloc s/op

解釋一下上述結果，在測試 Array 的時候，用的是4核，迴圈次數是500000，平均每次執行時間是3637 ns，每次執行堆上分配記憶體總量是0，分配次數也是0 。

而切片的結果就“差”一點，同樣也是用的是4核，迴圈次數是300000，平均每次執行時間是4055 ns，但是每次執行一次，堆上分配記憶體總量是8192，分配次數也是1 。

這樣對比看來，並非所有時候都適合用切片代替陣列，因為切片底層陣列可能會在堆上分配記憶體，而且小陣列在棧上拷貝的消耗也未必比
make 消耗大。

二. 切片的資料結構

切片本身並不是動態陣列或者陣列指標。它內部實現的資料結構通過指標引用底層陣列，設定相關屬性將資料讀寫操作限定在指定的區域內。切片本身是一個只讀物件，其工作機制類似陣列指標的一種封裝。

切片（slice）是對陣列一個連續片段的引用，所以切片是一個引用型別（因此更類似於 C/C++ 中的陣列型別，或者 Python 中的 list 型別）。這個片段可以是整個陣列，或者是由起始和終止索引標識的一些項的子集。需要注意的是，終止索引標識的項不包括在切片內。切片提供了一個與指向陣列的動態視窗。

給定項的切片索引可能比相關陣列的相同元素的索引小。和陣列不同的是，切片的長度可以在執行時修改，最小為 0 最大為相關陣列的長度：切片是一個長度可變的陣列。

Slice 的資料結構定義如下:

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

切片的結構體由3部分構成，Pointer 是指向一個陣列的指標，len 代表當前切片的長度，cap 是當前切片的容量。cap 總是大於等於 len 的。

 

如果想從 slice 中得到一塊記憶體地址，可以這樣做：

s := make([]byte, 200)
ptr := unsafe.Pointer(&s[0])

如果反過來呢？從 Go 的記憶體地址中構造一個 slice。

var ptr unsafe.Pointer
var s1 = struct {
    addr uintptr
    len int
    cap int
}{ptr, length, length}
s := *(*[]byte)(unsafe.Pointer(&s1))

構造一個虛擬的結構體，把 slice 的資料結構拼出來。

當然還有更加直接的方法，在 Go 的反射中就存在一個與之對應的資料結構 SliceHeader，我們可以用它來構造一個 slice

var o []byte
sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&o)))
sliceHeader.Cap = length
sliceHeader.Len = length
sliceHeader.Data = uintptr(ptr)

三. 建立切片

make 函式允許在執行期動態指定陣列長度，繞開了陣列型別必須使用編譯期常量的限制。

建立切片有兩種形式，make 建立切片，空切片。

1. make 和切片字面量

func makeslice(et *_type, len, cap int) slice {
    // 根據切片的資料型別，獲取切片的最大容量
    maxElements := maxSliceCap(et.size)
    // 比較切片的長度，長度值域應該在[0,maxElements]之間
    if len < 0 || uintptr(len) > maxElements {
        panic(errorString("makeslice: len out of range"))
    }
    // 比較切片的容量，容量值域應該在[len,maxElements]之間
    if cap < len || uintptr(cap) > maxElements {
        panic(errorString("makeslice: cap out of range"))
    }
    // 根據切片的容量申請記憶體
    p := mallocgc(et.size*uintptr(cap), et, true)
    // 返回申請好記憶體的切片的首地址
    return slice{p, len, cap}
}

還有一個 int64 的版本：

func makeslice64(et *_type, len64, cap64 int64) slice {
    len := int(len64)
    if int64(len) != len64 {
        panic(errorString("makeslice: len out of range"))
    }

    cap := int(cap64)
    if int64(cap) != cap64 {
        panic(errorString("makeslice: cap out of range"))
    }

    return makeslice(et, len, cap)
}

實現原理和上面的是一樣的，只不過多了把 int64 轉換成 int 這一步罷了。

 

 

上圖是用 make 函式建立的一個 len = 4， cap = 6 的切片。記憶體空間申請了6個 int 型別的記憶體大小。由於 len = 4，所以後面2個暫時訪問不到，但是容量還是在的。這時候陣列裡面每個變數都是0 。

除了 make 函式可以建立切片以外，字面量也可以建立切片。

 

 

這裡是用字面量建立的一個 len = 6，cap = 6 的切片，這時候陣列裡面每個元素的值都初始化完成了。需要注意的是 [ ] 裡面不要寫陣列的容量，因為如果寫了個數以後就是陣列了，而不是切片了。

 

 

還有一種簡單的字面量建立切片的方法。如上圖。上圖就 Slice A 建立出了一個 len = 3，cap = 3 的切片。從原陣列的第二位元素(0是第一位)開始切，一直切到第四位為止(不包括第五位)。同理，Slice B 建立出了一個 len = 2，cap = 4 的切片。

2. nil 和空切片

nil 切片和空切片也是常用的。

var slice []int

nil 切片被用在很多標準庫和內建函式中，描述一個不存在的切片的時候，就需要用到 nil 切片。比如函式在發生異常的時候，返回的切片就是 nil 切片。nil 切片的指標指向 nil。

空切片一般會用來表示一個空的集合。比如資料庫查詢，一條結果也沒有查到，那麼就可以返回一個空切片。

silce := make( []int , 0 )
slice := []int{ }

空切片和 nil 切片的區別在於，空切片指向的地址不是nil，指向的是一個記憶體地址，但是它沒有分配任何記憶體空間，即底層元素包含0個元素。

最後需要說明的一點是。不管是使用 nil 切片還是空切片，對其呼叫內建函式 append，len 和 cap 的效果都是一樣的。

四. 切片擴容

當一個切片的容量滿了，就需要擴容了。怎麼擴，策略是什麼？

func growslice(et *_type, old slice, cap int) slice {
    if raceenabled {
        callerpc := getcallerpc(unsafe.Pointer(&et))
        racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
    }
    if msanenabled {
        msanread(old.array, uintptr(old.len*int(et.size)))
    }

    if et.size == 0 {
        // 如果新要擴容的容量比原來的容量還要小，這代表要縮容了，那麼可以直接報panic了。
        if cap < old.cap {
            panic(errorString("growslice: cap out of range"))
        }

        // 如果當前切片的大小為0，還呼叫了擴容方法，那麼就新生成一個新的容量的切片返回。
        return slice{unsafe.Pointer(&zerobase), old.len, cap}
    }

  // 這裡就是擴容的策略
    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
            }
        }
    }

    // 計算新的切片的容量，長度。
    var lenmem, newlenmem, capmem uintptr
    const ptrSize = unsafe.Sizeof((*byte)(nil))
    switch et.size {
    case 1:
        lenmem = uintptr(old.len)
        newlenmem = uintptr(cap)
        capmem = roundupsize(uintptr(newcap))
        newcap = int(capmem)
    case ptrSize:
        lenmem = uintptr(old.len) * ptrSize
        newlenmem = uintptr(cap) * ptrSize
        capmem = roundupsize(uintptr(newcap) * ptrSize)
        newcap = int(capmem / ptrSize)
    default:
        lenmem = uintptr(old.len) * et.size
        newlenmem = uintptr(cap) * et.size
        capmem = roundupsize(uintptr(newcap) * et.size)
        newcap = int(capmem / et.size)
    }

    // 判斷非法的值，保證容量是在增加，並且容量不超過最大容量
    if cap < old.cap || uintptr(newcap) > maxSliceCap(et.size) {
        panic(errorString("growslice: cap out of range"))
    }

    var p unsafe.Pointer
    if et.kind&kindNoPointers != 0 {
        // 在老的切片後面繼續擴充容量
        p = mallocgc(capmem, nil, false)
        // 將 lenmem 這個多個 bytes 從 old.array地址 拷貝到 p 的地址處
        memmove(p, old.array, lenmem)
        // 先將 P 地址加上新的容量得到新切片容量的地址，然後將新切片容量地址後面的 capmem-newlenmem 個 bytes 這塊記憶體初始化。為之後繼續 append() 操作騰出空間。
        memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
    } else {
        // 重新申請新的陣列給新切片
        // 重新申請 capmen 這個大的記憶體地址，並且初始化為0值
        p = mallocgc(capmem, et, true)
        if !writeBarrier.enabled {
            // 如果還不能開啟寫鎖，那麼只能把 lenmem 大小的 bytes 位元組從 old.array 拷貝到 p 的地址處
            memmove(p, old.array, lenmem)
        } else {
            // 迴圈拷貝老的切片的值
            for i := uintptr(0); i < lenmem; i += et.size {
                typedmemmove(et, add(p, i), add(old.array, i))
            }
        }
    }
    // 返回最終新切片，容量更新為最新擴容之後的容量
    return slice{p, old.len, newcap}
}

上述就是擴容的實現。主要需要關注的有兩點，一個是擴容時候的策略，還有一個就是擴容是生成全新的記憶體地址還是在原來的地址後追加。

1. 擴容策略

先看看擴容策略。

func main() {
    slice := []int{10, 20, 30, 40}
    newSlice := append(slice, 50)
    fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    newSlice[1] += 10
    fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
}

輸出結果：

Before slice = [10 20 30 40], Pointer = 0xc4200b0140, len = 4, cap = 4
Before newSlice = [10 20 30 40 50], Pointer = 0xc4200b0180, len = 5, cap = 8
After slice = [10 20 30 40], Pointer = 0xc4200b0140, len = 4, cap = 4
After newSlice = [10 30 30 40 50], Pointer = 0xc4200b0180, len = 5, cap = 8

用圖表示出上述過程。

 

從圖上我們可以很容易的看出，新的切片和之前的切片已經不同了，因為新的切片更改了一個值，並沒有影響到原來的陣列，新切片指向的陣列是一個全新的陣列。並且 cap 容量也發生了變化。這之間究竟發生了什麼呢？

Go 中切片擴容的策略是這樣的：

如果切片的容量小於 1024 個元素，於是擴容的時候就翻倍增加容量。上面那個例子也驗證了這一情況，總容量從原來的4個翻倍到現在的8個。

一旦元素個數超過 1024 個元素，那麼增長因子就變成 1.25 ，即每次增加原來容量的四分之一。

注意：擴容擴大的容量都是針對原來的容量而言的，而不是針對原來陣列的長度而言的。

2. 新陣列 or 老陣列 ？

再談談擴容之後的陣列一定是新的麼？這個不一定，分兩種情況。

情況一：

func main() {
    array := [4]int{10, 20, 30, 40}
    slice := array[0:2]
    newSlice := append(slice, 50)
    fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    newSlice[1] += 10
    fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    fmt.Printf("After array = %v\n", array)
}

列印輸出：

Before slice = [10 20], Pointer = 0xc4200c0040, len = 2, cap = 4
Before newSlice = [10 20 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After slice = [10 30], Pointer = 0xc4200c0040, len = 2, cap = 4
After newSlice = [10 30 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After array = [10 30 50 40]

把上述過程用圖表示出來，如下圖。

 

通過列印的結果，我們可以看到，在這種情況下，擴容以後並沒有新建一個新的陣列，擴容前後的陣列都是同一個，這也就導致了新的切片修改了一個值，也影響到了老的切片了。並且 append() 操作也改變了原來陣列裡面的值。一個 append() 操作影響了這麼多地方，如果原陣列上有多個切片，那麼這些切片都會被影響！無意間就產生了莫名的 bug！

這種情況，由於原陣列還有容量可以擴容，所以執行 append() 操作以後，會在原陣列上直接操作，所以這種情況下，擴容以後的陣列還是指向原來的陣列。

這種情況也極容易出現在字面量建立切片時候，第三個引數 cap 傳值的時候，如果用字面量建立切片，cap 並不等於指向陣列的總容量，那麼這種情況就會發生。

slice := array[1:2:3]

上面這種情況非常危險，極度容易產生 bug 。

建議用字面量建立切片的時候，cap 的值一定要保持清醒，避免共享原陣列導致的 bug。

情況二：

情況二其實就是在擴容策略裡面舉的例子，在那個例子中之所以生成了新的切片，是因為原來陣列的容量已經達到了最大值，再想擴容， Go 預設會先開一片記憶體區域，把原來的值拷貝過來，然後再執行 append() 操作。這種情況絲毫不影響原陣列。

所以建議儘量避免情況一，儘量使用情況二，避免 bug 產生。

五. 切片拷貝

Slice 中拷貝方法有2個。

func slicecopy(to, fm slice, width uintptr) int {
    // 如果源切片或者目標切片有一個長度為0，那麼就不需要拷貝，直接 return 
    if fm.len == 0 || to.len == 0 {
        return 0
    }
    // n 記錄下源切片或者目標切片較短的那一個的長度
    n := fm.len
    if to.len < n {
        n = to.len
    }
    // 如果入參 width = 0，也不需要拷貝了，返回較短的切片的長度
    if width == 0 {
        return n
    }
    // 如果開啟了競爭檢測
    if raceenabled {
        callerpc := getcallerpc(unsafe.Pointer(&to))
        pc := funcPC(slicecopy)
        racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
        racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
    }
    // 如果開啟了 The memory sanitizer (msan)
    if msanenabled {
        msanwrite(to.array, uintptr(n*int(width)))
        msanread(fm.array, uintptr(n*int(width)))
    }

    size := uintptr(n) * width
    if size == 1 { 
        // TODO: is this still worth it with new memmove impl?
        // 如果只有一個元素，那麼指標直接轉換即可
        *(*byte)(to.array) = *(*byte)(fm.array) // known to be a byte pointer
    } else {
        // 如果不止一個元素，那麼就把 size 個 bytes 從 fm.array 地址開始，拷貝到 to.array 地址之後
        memmove(to.array, fm.array, size)
    }
    return n
}

在這個方法中，slicecopy 方法會把源切片值(即 fm Slice )中的元素複製到目標切片(即 to Slice )中，並返回被複制的元素個數，copy 的兩個型別必須一致。slicecopy 方法最終的複製結果取決於較短的那個切片，當較短的切片複製完成，整個複製過程就全部完成了。

 

舉個例子，比如：

func main() {
    array := []int{10, 20, 30, 40}
    slice := make([]int, 6)
    n := copy(slice, array)
    fmt.Println(n,slice)
}

還有一個拷貝的方法，這個方法原理和 slicecopy 方法類似，不在贅述了，註釋寫在程式碼裡面了。

func slicestringcopy(to []byte, fm string) int {
    // 如果源切片或者目標切片有一個長度為0，那麼就不需要拷貝，直接 return 
    if len(fm) == 0 || len(to) == 0 {
        return 0
    }
    // n 記錄下源切片或者目標切片較短的那一個的長度
    n := len(fm)
    if len(to) < n {
        n = len(to)
    }
    // 如果開啟了競爭檢測
    if raceenabled {
        callerpc := getcallerpc(unsafe.Pointer(&to))
        pc := funcPC(slicestringcopy)
        racewriterangepc(unsafe.Pointer(&to[0]), uintptr(n), callerpc, pc)
    }
    // 如果開啟了 The memory sanitizer (msan)
    if msanenabled {
        msanwrite(unsafe.Pointer(&to[0]), uintptr(n))
    }
    // 拷貝字串至位元組陣列
    memmove(unsafe.Pointer(&to[0]), stringStructOf(&fm).str, uintptr(n))
    return n
}

再舉個例子，比如：

func main() {
    slice := make([]byte, 3)
    n := copy(slice, "abcdef")
    fmt.Println(n,slice)
}

輸出：

3 [97,98,99]

說到拷貝，切片中有一個需要注意的問題。

func main() {
    slice := []int{10, 20, 30, 40}
    for index, value := range slice {
        fmt.Printf("value = %d , value-addr = %x , slice-addr = %x\n", value, &value, &slice[index])
    }
}

輸出：

value = 10 , value-addr = c4200aedf8 , slice-addr = c4200b0320
value = 20 , value-addr = c4200aedf8 , slice-addr = c4200b0328
value = 30 , value-addr = c4200aedf8 , slice-addr = c4200b0330
value = 40 , value-addr = c4200aedf8 , slice-addr = c4200b0338

從上面結果我們可以看到，如果用 range 的方式去遍歷一個切片，拿到的 Value 其實是切片裡面的值拷貝。所以每次列印 Value 的地址都不變。

 

 

由於 Value 是值拷貝的，並非引用傳遞，所以直接改 Value 是達不到更改原切片值的目的的，需要通過 &slice[index] 獲取真實的地址。

 

 

原文地址：https://www.jianshu.com/p/030aba2bff41