go slice append
切片的底层是一个数组，如果截取切片的一部分赋给另一个切片，那这两个切片的数据其实指向的是同一个数组，如果没有发生扩容则修改其中一个切片的值会影响另一个切片的值。
arr := make([]int, 0, 6)
arr = append(arr, 1, 2, 3)
newSlice := append(arr, 4)
fmt.Println(newSlice) // [1,2,3,4]
arr = append(arr,5)
arr = append(arr,6)
fmt.Println(newSlice) // [1,2,3,5]
那么怎么避免上述问题呢，答案是用copy函数
arr := make([]int, 6)
arr = append(arr, 1, 2, 3)
newSlice := make([]int, len(arr))
copy(newSlice, arr) //copy 或者 newSlice = append([]int{}, arr...) 都可以
fmt.Println(newSlice) // [1,2,3]
arr = append(arr, 5)
arr = append(arr, 6)
fmt.Println(newSlice) // [1,2,3]
上面第一个有问题是因为没有发生扩容，容量足够，所以两个切片共享一个数组，修改了其中一个则会影响第二个，如果稍微改下，让其发生扩容，则不影响原来切片的元素
var arr []int
arr = append(arr, 1, 2, 3)
newSlice := append(arr, 4)
fmt.Println(newSlice) // [1,2,3,4]
arr = append(arr,5)
arr = append(arr,6)
fmt.Println(newSlice) // [1,2,3,4]
arr切片一开始容量为0,第一次append之后容量是3，此时再append进去一个4后，发现容量不够了则会发生扩容，开辟一块新的内存空间然后赋给了newSlice，newSlice的容量为6，这时arr和newSlice不共享同一个数组，所以修改其中一个不影响另一个。
原理
对切片进行append后，如果不是赋值给原来的切片，则走inplace=false这个逻辑，如果原来切片的容量不够则调用growslice方法对切片进行扩容
// go1.17.8 darwin/amd64 cmd/compile/internal/ssagen/ssa.go:3255
func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
// If inplace is false, process as expression "append(s, e1, e2, e3)":
//
// ptr, len, cap := s
// newlen := len + 3
// if newlen > cap {
// ptr, len, cap = growslice(s, newlen)
// newlen = len + 3 // recalculate to avoid a spill
// }
// // with write barriers, if needed:
// *(ptr+len) = e1
// *(ptr+len+1) = e2
// *(ptr+len+2) = e3
// return makeslice(ptr, newlen, cap)
}
那问题来了，怎么知道append后容量是否足够呢
func growslice(et *_type, old slice, cap int) slice {
newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
newcap = cap
} else {
if old.cap < 1024 {
newcap = doublecap
} else {
for 0 < newcap && newcap < cap {
newcap += newcap / 4
}
if newcap <= 0 {
newcap = cap
}
}
}
var overflow bool
var lenmem, newlenmem, capmem uintptr
switch {
case et.size == 1:
lenmem = uintptr(old.len)
newlenmem = uintptr(cap)
capmem = roundupsize(uintptr(newcap))
overflow = uintptr(newcap) > maxAlloc
newcap = int(capmem)
case et.size == sys.PtrSize:
lenmem = uintptr(old.len) * sys.PtrSize
newlenmem = uintptr(cap) * sys.PtrSize
capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
overflow = uintptr(newcap) > maxAlloc/sys.PtrSize
newcap = int(capmem / sys.PtrSize)
case isPowerOfTwo(et.size):
...
default:
...
}
}
// runtime/msize.go:13
func roundupsize(size uintptr) uintptr {
if size < _MaxSmallSize {
if size <= smallSizeMax-8 {
return uintptr(class_to_size[size_to_class8[divRoundUp(size, smallSizeDiv)]])
} else {
return uintptr(class_to_size[size_to_class128[divRoundUp(size-smallSizeMax, largeSizeDiv)]])
}
}
if size+_PageSize < size {
return size
}
return alignUp(size, _PageSize)
}
growslice里对于容量小于1024的则直接翻倍，大于1024的每次增加25%，当然这只是预分配。
以上面第3个例子为准，arr底层数组是一个int类型，我的机器上是64位，一个元素则占用8个字节，一开始arr的长度和容量都是0，第一次append后发生扩容，元素个数是3个，大小是24个字节，容量至少得分配24个字节才能够，（看下面这个表，这个表是go里面的注释，代码是以数组的形式表现的），24个字节容量就是3。刚好放得下，所以arr第一次append后的容量是3
newSlice := append(arr, 4)后继续扩容，元素是4个，arr容量此时为3，4个元素至少得32个字节才放得下，doublecap 此时为6，期望分配的容量cap是4，cap 此时小于 doublecap，所以doublecap就是预分配的容量6，然后根据下表48个字节，容量6个刚好够，则最终容量是6。
如果arr = append(arr, 1,2,3,4,5)，那最终分配的容量也是6，我们来算下，期望分配的是5个元素，也就是40个字节，arr原本的容量为0，则不直接翻倍，预分配40个字节，因为元素的大小刚好等于sys.PtrSize，所以调用roundupsize计算最终的分配，roundupsize里干的事儿其实就是下面这个表（我只截取了一部分），40在32到48之间，所以只能向上取整48个字节，也就是容量为6.
// class bytes/obj bytes/span objects tail waste max waste min align
// 1 8 8192 1024 0 87.50% 8
// 2 16 8192 512 0 43.75% 16
// 3 24 8192 341 8 29.24% 8
// 4 32 8192 256 0 21.88% 32
// 5 48 8192 170 32 31.52% 16
// 6 64 8192 128 0 23.44% 64
// 7 80 8192 102 32 19.07% 16
// 8 96 8192 85 32 15.95% 32
// 9 112 8192 73 16 13.56% 16
// 10 128 8192 64 0 11.72% 128
// 11 144 8192 56 128 11.82% 16
// 12 160 8192 51 32 9.73% 32
