数组的初始化

  1. package main
  3. import "fmt"
  5. func echo(x [4]int) {
  6.     fmt.Println(x)
  7. }
  9. func main() {
  11.     // 变量 a 类型为 [4]int 是一个 type，每个元素自动初始化为 int 的零值（zero-value）
  12.     var a [4]int
  14.     // 变量 b 类型为 [5]int 是不同于 [4]int 的类型，且 b[4] 会自动初始化为 int 的零值
  15.     b := [5]int{1, 2, 3, 4}
  17.     // 变量 c 被自动推导为 [5]int 类型，与 b 类型同
  18.     c := [...]int{1, 2, 3, 4, 5}
  20.     // a里面的所有元素都会被复制一遍、因为go语言的函数传参是 值传递
  21.     echo(a)
  22.     fmt.Println("b: ", b)
  23.     fmt.Println("c: ", c)
  24. }

slice 初始化

  1. package main
  3. import "fmt"
  5. func main() {
  7.     // 借助 make 函数，此时 len = cap = 5，每个元素初始化为 byte 的 zero-value
  8.     s0 := make([]byte, 5)
  10.     // 字面值初始化，此时 len = cap = 5
  11.     s1 := []byte{0, 0, 0, 0, 0}
  13.     // 自动初始化为 slice 的“零值(zero-value)”：nil
  14.     var s2 []byte
  16.     fmt.Println("s0: ", s0)
  17.     fmt.Println("s1: ", s1)
  18.     fmt.Println("s2: ", s2)
  20. }

数组和切片的不同

  • 数组定义后长度不可变、而切片可变
  • 切片是引用类型、而数组是 值类型、
  • 引用类型的除了切片还有map、channel、函数等
  • 值类型的有 基础数据类型 和 结构体类型

查看数组及切片的长度、容量

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // 创建一个slice 其实就是分配内存、cap 和 len的设置是在汇编中完成的
  7.     s1 := make([]int, 5)
  8.     fmt.Printf("The length of s1: %d\n", len(s1))
  9.     fmt.Printf("The capacity of s1: %d\n", cap(s1))
  10.     fmt.Printf("The value of s1: %d\n", s1)
  11.     s2 := make([]int, 5, 8)
  12.     fmt.Printf("The length of s2: %d\n", len(s2))
  13.     fmt.Printf("The capacity of s2: %d\n", cap(s2))
  14.     fmt.Printf("The value of s2: %d\n", s2)
  15. }

切片同时 指向一个底层数组

  1. package main
  3. import "fmt"
  5. func main() {
  7.     s3 := []int{1, 2, 3, 4, 5, 6, 7, 8}
  8.     s4 := s3[3:6]
  9.     fmt.Printf("The length of s4: %d\n", len(s4))
  10.     fmt.Printf("The capacity of s4: %d\n", cap(s4))
  11.     fmt.Printf("The value of s4: %d\n", s4)
  13.     fmt.Printf("s3中的 元素4地址是: %d\n", &s3[3])
  14.     fmt.Printf("s4中的 元素4地址是: %d\n", &s4[0])
  15. }
  17. /**
  19. Output: 
  21. The length of s4: 3
  22. The capacity of s4: 5
  23. The value of s4: [4 5 6]
  24. s3中的 元素4地址是: 824633827544
  25. s4中的 元素4地址是: 824633827544
  27. */

切片的底层数组 什么时候被替换？

  • 准确来说 一个切片的底层数组永远不会被替换
  • 虽然扩容时、Go语言一定会生成一个新的底层数组、但同时也生成了新的切片
  • 在 容量足够的情况下、append函数返回的是 指向原切片的底层数组
  • append 需要扩容时、返回的是 指向 新底层数组的新切片

slice 源码解析

代码位置 runtime/slice.go

make

  1. func makeslice(et *_type, len, cap int) unsafe.Pointer {
  3.     // 获取需要申请的内存大小
  4.     // overflow 乘法是否溢出、这里指的是 size * cap 是否溢出
  5.     // mem 等于 size * cap
  6.     mem, overflow := math.MulUintptr(et.size, uintptr(cap))
  8.     // 如果溢出了 或 
  9.     // size * cap大于最大分配 或
  10.     // len 小于0 或
  11.     // len 大于 cap 
  12.     // 都会报错、len上限超出范围 或者 cap上限超出范围
  13.     if overflow || mem > maxAlloc || len < 0 || len > cap {
  14.         // NOTE: Produce a 'len out of range' error instead of a
  15.         // 'cap out of range' error when someone does make([]T, bignumber).
  16.         // 'cap out of range' is true too, but since the cap is only being
  17.         // supplied implicitly, saying len is clearer.
  18.         // See golang.org/issue/4085.
  19.         mem, overflow := math.MulUintptr(et.size, uintptr(len))
  20.         if overflow || mem > maxAlloc || len < 0 {
  21.             panicmakeslicelen()
  22.         }
  23.         panicmakeslicecap()
  24.     }
  26.     // 分配 slice内存
  27.     // 小对象从 当前 P的 cache中空闲数据里面分配
  28.     // 大对象 (size > 32KB) 直接从 heap(堆) 中分配
  29.     return mallocgc(mem, et, true)
  30. }

append

  1. func growslice(et *_type, old slice, cap int) slice {
  3.     // 是否开启 race检测、也就是数据竞争检测
  4.     if raceenabled {
  5.         callerpc := getcallerpc()
  6.         racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
  7.     }
  9.     // 是否开启内存扫描
  10.     if msanenabled {
  11.         msanread(old.array, uintptr(old.len*int(et.size)))
  12.     }
  14.     // 新容量如果小于 当前容量直接 panic
  15.     if cap < old.cap {
  16.         panic(errorString("growslice: cap out of range"))
  17.     }
  19.     // 存储的类型空间为0、长度不为空、则重新创建
  20.     if et.size == 0 {
  21.         // append should not create a slice with nil pointer but non-zero len.
  22.         // We assume that append doesn't need to preserve old.array in this case.
  23.         return slice{unsafe.Pointer(&zerobase), old.len, cap}
  24.     }
  26.     newcap := old.cap
  27.     doublecap := newcap + newcap
  28.     if cap > doublecap {
  29.         // 如果新容量大于 原有容量的两倍、则直接按照新增容量大小申请
  30.         newcap = cap
  31.     } else {
  32.         if old.len < 1024 {
  33.             // 如果原有长度 小于1024 kb、新容量则按照两倍创建
  34.             newcap = doublecap
  35.         } else {
  37.             // 大于1024kb 按照原有容量的 1/4 扩容、直到满足新容量的需要
  38.             // Check 0 < newcap to detect overflow
  39.             // and prevent an infinite loop.
  40.             for 0 < newcap && newcap < cap {
  41.                 newcap += newcap / 4
  42.             }
  44.             // 检查新容量 是否溢出、如果溢出 则使用现有的容量
  45.             // Set newcap to the requested cap when
  46.             // the newcap calculation overflowed.
  47.             if newcap <= 0 {
  48.                 newcap = cap
  49.             }
  50.         }
  51.     }
  54.     // 为了加速计算、对于不同的slice 元素大小、
  55.     // 选择不同的计算方法、获取需要申请的内存大小
  56.     var overflow bool
  57.     var lenmem, newlenmem, capmem uintptr
  58.     // Specialize for common values of et.size.
  59.     // For 1 we don't need any division/multiplication.
  60.     // For sys.PtrSize, compiler will optimize division/multiplication into a shift by a constant.
  61.     // For powers of 2, use a variable shift.
  62.     switch {
  63.     case et.size == 1:
  64.         lenmem = uintptr(old.len)
  65.         newlenmem = uintptr(cap)
  66.         capmem = roundupsize(uintptr(newcap))
  67.         overflow = uintptr(newcap) > maxAlloc
  68.         newcap = int(capmem)
  69.     case et.size == sys.PtrSize:
  70.         lenmem = uintptr(old.len) * sys.PtrSize
  71.         newlenmem = uintptr(cap) * sys.PtrSize
  72.         capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
  73.         overflow = uintptr(newcap) > maxAlloc/sys.PtrSize
  74.         newcap = int(capmem / sys.PtrSize)
  75.     case isPowerOfTwo(et.size):
  77.         // 2的倍数 用位移计算
  78.         var shift uintptr
  79.         if sys.PtrSize == 8 {
  80.             // Mask shift for better code generation.
  81.             shift = uintptr(sys.Ctz64(uint64(et.size))) & 63
  82.         } else {
  83.             shift = uintptr(sys.Ctz32(uint32(et.size))) & 31
  84.         }
  85.         lenmem = uintptr(old.len) << shift
  86.         newlenmem = uintptr(cap) << shift
  87.         capmem = roundupsize(uintptr(newcap) << shift)
  88.         overflow = uintptr(newcap) > (maxAlloc >> shift)
  89.         newcap = int(capmem >> shift)
  90.     default:
  92.         // 其他计算用 除法
  93.         lenmem = uintptr(old.len) * et.size
  94.         newlenmem = uintptr(cap) * et.size
  95.         capmem, overflow = math.MulUintptr(et.size, uintptr(newcap))
  96.         capmem = roundupsize(capmem)
  97.         newcap = int(capmem / et.size)
  98.     }
  100.     // The check of overflow in addition to capmem > maxAlloc is needed
  101.     // to prevent an overflow which can be used to trigger a segfault
  102.     // on 32bit architectures with this example program:
  103.     //
  104.     // type T [1<<27 + 1]int64
  105.     //
  106.     // var d T
  107.     // var s []T
  108.     //
  109.     // func main() {
  110.     //   s = append(s, d, d, d, d)
  111.     //   print(len(s), "\n")
  112.     // }
  114.     // 判断是否溢出
  115.     if overflow || capmem > maxAlloc {
  116.         panic(errorString("growslice: cap out of range"))
  117.     }
  119.     // 内存分配
  120.     var p unsafe.Pointer
  121.     if et.ptrdata == 0 {
  122.         p = mallocgc(capmem, nil, false)
  123.         // The append() that calls growslice is going to overwrite from old.len to cap (which will be the new length).
  124.         // Only clear the part that will not be overwritten.
  125.         // 清空不需要数据拷贝的部分内存
  126.         memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
  127.     } else {
  128.         // Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.
  129.         p = mallocgc(capmem, et, true)
  130.         // gc相关
  131.         if lenmem > 0 && writeBarrier.enabled {
  132.             // Only shade the pointers in old.array since we know the destination slice p
  133.             // only contains nil pointers because it has been cleared during alloc.
  134.             bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(old.array), lenmem)
  135.         }
  136.     }
  138.     // 数据拷贝
  139.     memmove(p, old.array, lenmem)
  141.     return slice{p, old.len, newcap}
  142. }

copy

  1. func slicecopy(to, fm slice, width uintptr) int {
  2.     if fm.len == 0 || to.len == 0 {
  3.         return 0
  4.     }
  6.     n := fm.len
  7.     if to.len < n {
  8.         n = to.len
  9.     }
  11.     // 元素大小为0、直接返回
  12.     if width == 0 {
  13.         return n
  14.     }
  16.     // 数据竞争检测
  17.     if raceenabled {
  18.         callerpc := getcallerpc()
  19.         pc := funcPC(slicecopy)
  20.         racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
  21.         racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
  22.     }
  24.     // 内存扫描
  25.     if msanenabled {
  26.         msanwrite(to.array, uintptr(n*int(width)))
  27.         msanread(fm.array, uintptr(n*int(width)))
  28.     }
  30.     size := uintptr(n) * width
  31.     if size == 1 { // common case worth about 2x to do here
  32.         // TODO: is this still worth it with new memmove impl?
  33.         // 直接拷贝
  34.         *(*byte)(to.array) = *(*byte)(fm.array) // known to be a byte pointer
  35.     } else {
  36.         // 拷贝
  37.         memmove(to.array, fm.array, size)
  38.     }
  39.     return n
  40. }
  44. // 字符串slice的拷贝
  45. func slicestringcopy(to []byte, fm string) int {
  46.     if len(fm) == 0 || len(to) == 0 {
  47.         return 0
  48.     }
  50.     n := len(fm)
  51.     if len(to) < n {
  52.         n = len(to)
  53.     }
  55.     if raceenabled {
  56.         callerpc := getcallerpc()
  57.         pc := funcPC(slicestringcopy)
  58.         racewriterangepc(unsafe.Pointer(&to[0]), uintptr(n), callerpc, pc)
  59.     }
  60.     if msanenabled {
  61.         msanwrite(unsafe.Pointer(&to[0]), uintptr(n))
  62.     }
  64.     memmove(unsafe.Pointer(&to[0]), stringStructOf(&fm).str, uintptr(n))
  65.     return n
  66. }