深入理解go的slice深入，slice扩容机制-go深入-利志分享

深入理解go的slice深入，slice扩容机制

阅读：348 分享次数：0

关于slice是go里面最常见也用得最多的数据结构，我们翻一下源码看下结构，路径在Go/src/runtime/slice.go文件里面。

type slice struct {
    	array unsafe.Pointer
    	len   int
    	cap   int
    }
	
slice是由一个array指针指向底层数组，len表示切片长度，cap表示切片容量。其实关于slice的理解，主要是要知道它的扩容机制，了解扩容机制就能深刻理解slice。

首先我们来看一个例子：

package main
    
    import "fmt"
    
    func main() {
    	slice1 := []int{}
    	oldCap := cap(slice1)
    	for i := 0; i < 2048; i++ {
    		slice1 = append(slice1, i)
    		newCap := cap(slice1)
    		if newCap != oldCap {
    			fmt.Printf("%p %p cap=%d\n", &slice1, slice1, cap(slice1))
    			oldCap = newCap
    		}
    	}
    
    }
	
执行结果如下：

0xc000004480 0xc00000a0b0 cap=1
    0xc000004480 0xc00000a0e0 cap=2
    0xc000004480 0xc0000103c0 cap=4
    0xc000004480 0xc00000e200 cap=8
    0xc000004480 0xc000018100 cap=16
    0xc000004480 0xc000000500 cap=32
    0xc000004480 0xc000076000 cap=64
    0xc000004480 0xc000078000 cap=128
    0xc000004480 0xc00007a000 cap=256
    0xc000004480 0xc00007c000 cap=512
    0xc000004480 0xc00007e000 cap=1024
    0xc000004480 0xc000110000 cap=1280
    0xc000004480 0xc00011a000 cap=1696
    0xc000004480 0xc000124000 cap=2304

上面slice1,它的地址是不变的，但是他执行的值是变化的，初始化的时候是0xc00000a0b0，第一次增加内容会扩容所以值得地址是变化的，因为复制了内存，slice1的指向新的一块内存。第二次，第三次，slice1的容量都是够的，到第三次刚好是初始化的两倍，第四次的时候扩容之后slice1又指向了新的地址。上面的例子能够很好的说明slice的扩容变化。我们这里下面总结一下：
扩容的基本原则：
1. 如果slice的容量小于1024，则新的扩容会是原来的2倍。
2. 如果原来的slice的容量大于或者等于1024，则新的扩容将扩大大于或者等于原来1.25倍（网上其实很多总结都是错误的。）。

对于切片的扩容，当切片比较小的，采用较大的扩容倍速进行扩容，避免频繁扩容，从而减少内存分配的次数和数据拷贝的代价。
当切片较大的时，采用较小的扩容倍速，主要避免空间浪费。

对于append向slice添加元素的步骤：
1. 加入slice容量够用，则追加新元素进去，slice.len++，返回原来的slice。
2. 当原容量不够，则slice先扩容，扩容之后得到新的slice，将元素追加进新的slice，slice.len++，返回新的slice。

下面我们再看一个特殊的例子：

package main
    
    import "fmt"
    
    func main() {
    	s := []int{5}
    	s = append(s, 7)
    	s = append(s, 9)
    	x := append(s, 11)
    	y := append(s, 12)
    	fmt.Printf("s:%v, x:%v, y:%v", s, x, y)
    }
	
结果如下：

s:[5 7 9], x:[5 7 9 12], y:[5 7 9 12]
为什么x和y的值是一样呢？如果看完上面的扩容机制，相信大家都能知道，当执行x := append(s, 11)这行代码的时候容量是4，所以11是直接加到s里面去的，当执行y := append(s, 12)这行代码的时候容量还是4，所以12是直接追加到s里面去的，把之前那个11进行覆盖了，因为给x赋值和给y赋值，s在执行s = append(s, 9)这行代码的时候已经扩容好了还剩下一个位置，所以给x和y的赋值都是追加到s的最后一个位置。所以会出现x和y是最后相同的值。
	
最后我们看看这个例子：

package main
    
    import "fmt"
    
    func main() {
    	s := []int{5, 7, 9}
    	x := append(s, 11)
    	y := append(s, 12)
    	fmt.Printf("s:%v, x:%v, y:%v", s, x, y)
    }
结果如下：

s:[5 7 9], x:[5 7 9 11], y:[5 7 9 12]
这里的x和y就会不一样。原因是因为s执行x := append(s, 11)的时候扩容了，执行了y := append(s, 12)也在s的基础上进行扩容了，扩容了之后x和y指向的是不同的内存，x和y有不同的内存地址。

slice扩容总结：
- **如果slice的容量小于1024，则新的扩容会是原来的2倍。**
- **如果原来的slice的容量大于或者等于1024，则新的扩容将扩大大于或者等于原来1.25倍。**

感觉本站内容不错，读后有收获？

我要小额打赏，鼓励作者写出更好的教程

扫码关注公众号：talk_lizhi