一.前言
好久之前单独的写过一篇 golong 切片的源码分析，几天前写代码，遇到了append函数，又是被坑了一下，决定带着问题跟大家一起回顾一下 golang 切片。
二.详细介绍
切片基础概念
切片是围绕动态数组的概念构建的，可以按需自动增长和缩小。(注意:切片传递的是指针的拷贝值，所以可以在函数里面修改指针指向的值，对外有影响)
切片的自动增长是通过 append()函数来实现的
切片的底层内存也是在连续块中分配的，所以切片还能获得索引，迭代以及为垃圾回收优化的好处。
引入问题
请关注下面的代码
arr:=[]int{1,2,3}//初始化一个包含三个元素的切片 tmp:=append(arr[:1],arr[2:]...)//删除切片中间的值 fmt.Println(&tmp[0])//打印tmp切片0位地址的值 0xc0000b8020 fmt.Println(&arr[0])//打印原始切片0位地址的值 0xc0000b8020 fmt.Println(len(tmp))//查看tmp切片的长度 2 fmt.Println(len(arr))//查看arr切片的长度 3 fmt.Println(cap(tmp))//查看tmp切片的容积 3 fmt.Println(cap(arr))//查看arr切片的容积 3 fmt.Println(tmp)//打印tmp的值 [1,3] fmt.Println(arr)//打印arr的值 [1,3,3] tmp = append(arr,[]int{4,5,6}...)//为切片arr追加3个值 fmt.Println(&arr[0])//打印原始切片0位地址的值 0xc0000b8020 fmt.Println(&tmp[0])//打印tmp切片0位地址的值 0xc0000ae030 fmt.Println(len(tmp))//查看tmp切片的长度 6 fmt.Println(len(arr))//查看arr切片的长度 3 fmt.Println(cap(tmp))//查看tmp切片的容积 6 fmt.Println(cap(arr))//查看arr切片的容积 3 fmt.Println(tmp)//打印tmp的值 1 3 3 4 5 6 fmt.Println(arr)//打印arr的值 1 3 3
复制代码
第一次操作后
程序中只有一个动态数组，这个数组类型是 int，申请了 24 个字节(64 位机器所以 1 个 int 类型 8 字节)
arr,tmp 共同指向这个数组的地址空间，意味着改变 tmp 内的值，arr 内的值也会跟着变化，反之亦然
arr 数组可以操作所有 24 个字节，因为他的长度是 2，tmp 数组只允许操作 16 个字节，因为长度为 2
第二次操作后
程序中有两个动态数组，一个占据 24 字节，一个占据 48 字节
arr 指向 24 字节的动态数组，tmp 指向 48 字节的动态数组，改变其中一者的值，另外的不会再受到变化。
根据 len 的长度，tmp 可以操作 48 个字节，arr 可以操作 24 个字节
提问与解答
1.len 和 cap 操作的区别对于切片是什么？他们代表什么含义
说到 len 和 cap，我们先来看一看切片的数据结构及初始化：
//切片数据结构type slice struct { array unsafe.Pointer//切片指针地址 len int//切片长度 cap int//容量}//初始化例子s = make([]int, 5, 10)
复制代码
该语句的含义是创建一个长度为 5，容量为 10 的切片
由于切片是动态数组，所以他的长度是不定的，那么初始化应该分配多少内存就是程序需要考虑的问题，go 语言使用 make 函数，显式申请 slice 的长度，这里与相同长度的数组一致，区别就在于容量。
如果使用数组，当数组长度增加的时候我们需要重新申请一段全新的内存用于存储数据，但是使用切片，我们可以提前分配好将来可能要使用的内存，一次申请多于当前要使用的量。
修改代码，可以验证如上结论：
arr:=make([]int,3,6) for i:=0;i<3;i++{ arr[i] = i+1 } fmt.Println(len(arr))// 3 fmt.Println(cap(arr))// 6 fmt.Println(arr) // [1 2 3] tmp := append(arr,[]int{4,5,6}...) fmt.Println(&arr[0])// 0xc00001a1e0 fmt.Println(&tmp[0])// 0xc00001a1e0 fmt.Println(len(arr))// 3 fmt.Println(cap(arr))// 6 fmt.Println(arr)// [1 2 3] fmt.Println(tmp)// [1 2 3 4 5 6]
复制代码
如上述代码，当我们提前给切片 arr 分配了 6 个 int 类型的长度，再次进行 append 操作的时候由于地址 0xc00001a1e0 后面添加的 4，5，6 可以被放入预留的内存段中，所以指针指向的地址不会发生任何变化。
len获取的是当前切片可用长度，cap获取的是当前切片提前申请的最大可用长度，cap一定大于等于len，cap的意义在于切片可用提前预留内存，这样自动增长的时候就不必每次都重新进行内存申请。
2.为什么同样是 append 操作，第一次内存地址指向不变，第二次返回了新的内存地址？
这个需要我们来关注一下 golang 的 append 命令的内部实现及内存申请规律，直接从代码入手
func growslice(et *_type, old slice, cap int) slice { if raceenabled { callerpc := getcallerpc() racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice)) } if msanenabled { msanread(old.array, uintptr(old.len*int(et.size))) } //禁止缩小容量 if cap < old.cap { panic(errorString("growslice: cap out of range")) } //类型为空指针则默认不保存原切片所有内容，但是保留长度，并以新的cap获取新内存(不知道什么时候会出现若有知晓的还望指教) if et.size == 0 { // append should not create a slice with nil pointer but non-zero len. // We assume that append doesn't need to preserve old.array in this case. return slice{unsafe.Pointer(&zerobase), old.len, cap} } newcap := old.cap doublecap := newcap + newcap //若新申请的cap大于旧的二倍，则取新的，否则取旧的 if cap > doublecap { newcap = cap } else { //若旧的长度小于1024，则乘以两倍，否则增加1.25倍 if old.len < 1024 { newcap = doublecap } else { // Check 0 < newcap to detect overflow // and prevent an infinite loop. for 0 < newcap && newcap < cap { newcap += newcap / 4 } // Set newcap to the requested cap when // the newcap calculation overflowed. if newcap <= 0 { newcap = cap } } }
var overflow bool var lenmem, newlenmem, capmem uintptr // 根据不同单位值采取不同的计算方式 switch { case et.size == 1: //若是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): var shift uintptr if sys.PtrSize == 8 { // Mask shift for better code generation. shift = uintptr(sys.Ctz64(uint64(et.size))) & 63 } else { shift = uintptr(sys.Ctz32(uint32(et.size))) & 31 } lenmem = uintptr(old.len) << shift newlenmem = uintptr(cap) << shift capmem = roundupsize(uintptr(newcap) << shift) overflow = uintptr(newcap) > (maxAlloc >> shift) newcap = int(capmem >> shift) default: lenmem = uintptr(old.len) * et.size newlenmem = uintptr(cap) * et.size capmem, overflow = math.MulUintptr(et.size, uintptr(newcap)) capmem = roundupsize(capmem) newcap = int(capmem / et.size) }
// The check of overflow in addition to capmem > maxAlloc is needed // to prevent an overflow which can be used to trigger a segfault // on 32bit architectures with this example program: // // type T [1<<27 + 1]int64 // // var d T // var s []T // // func main() { // s = append(s, d, d, d, d) // print(len(s), "\n") // } if overflow || capmem > maxAlloc { panic(errorString("growslice: cap out of range")) }
var p unsafe.Pointer if et.kind&kindNoPointers != 0 { p = mallocgc(capmem, nil, false) // The append() that calls growslice is going to overwrite from old.len to cap (which will be the new length). // Only clear the part that will not be overwritten. memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem) } else { // Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory. p = mallocgc(capmem, et, true) if writeBarrier.enabled { // Only shade the pointers in old.array since we know the destination slice p // only contains nil pointers because it has been cleared during alloc. bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(old.array), lenmem) } } memmove(p, old.array, lenmem)
return slice{p, old.len, newcap}}
复制代码
函数append会智能地处理底层数组的容量增长。在切片的容量小于1024个元素时，总是会成倍地增加容量，一旦元素个数超过1000，容量的增长因子会设为1.25，每次增长25%，实验证明如下。
func main() { arr:=make([]int,0,2) s:=cap(arr) for i:=0;i<2000;i++{ arr = append(arr,i) t:=cap(arr) if t>s{ s = t fmt.Println(t) } }}内容：4 8 16 32 64 128 256 512 1024 1280 1696 2304
复制代码
评论