Golang 切片（slice）扩容机制源码剖析
目录
我们知道 Golang 切片（slice） 在容量不足的情况下会进行扩容，扩容的原理是怎样的呢？是不是每次扩一倍？下面我们结合源码来告诉你答案。
一、源码
Version : go1.15.6 src/runtime/slice.go
-
//go1.15.6 源码 src/runtime/slice.go
-
func growslice(et *_type, old slice, cap int) slice {
-
//省略部分判断代码
-
//计算扩容部分
-
//其中，cap : 所需容量，newcap : 最终申请容量
-
newcap := old.cap
-
doublecap := newcap + newcap
-
if cap > doublecap {
-
newcap = cap
-
} else {
-
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
-
}
-
}
-
}
-
-
//省略部分判断代码
-
}
二、原理
1. 如果当前所需容量 （cap） 大于原先容量的两倍 （doublecap），则最终申请容量（newcap）为当前所需容量（cap）；
2. 如果<条件1>不满足，表示当前所需容量（cap）不大于原容量的两倍（doublecap），则进行如下判断；
3. 如果原切片长度（old.len）小于1024，则最终申请容量（newcap）等于原容量的两倍（doublecap）；
4. 否则，最终申请容量（newcap，初始值等于 old.cap）每次增加 newcap/4，直到大于所需容量（cap）为止，然后，判断最终申请容量（newcap）是否溢出，如果溢出，最终申请容量（newcap）等于所需容量（cap）；
这样说大家可能不太明白，来几个例子：
2.1 实例1
验证条件1：
-
package main
-
-
import "fmt"
-
-
func main() {
-
//第1条中的例子：
-
var slice = []int{1, 2, 3}
-
var slice1 = []int{4, 5, 6, 7, 8, 9, 10, 11, 12}
-
fmt.Printf("slice %v len = %v cap = %v\n", slice, len(slice), cap(slice))
-
fmt.Printf("slice1 %v len = %v cap = %v\n", slice1, len(slice1), cap(slice1))
-
slice = append(slice, slice1...)
-
fmt.Printf("slice %v len = %v cap = %v\n", slice, len(slice), cap(slice))
-
}
输出：
-
[root@localhost test]# go run main.go
-
slice [1 2 3] len = 3 cap = 3
-
slice1 [4 5 6 7 8 9 10 11 12] len = 9 cap = 9
-
slice [1 2 3 4 5 6 7 8 9 10 11 12] len = 12 cap = 12
-
[root@localhost test]#
在实例1中，所需容量 cap = 9+3 = 12，原容量的两倍 doublecap = 2 * 3 = 6，满足 <条件1> 即：所需容量大于原容量的两倍，所以最终申请容量 newcap = cap = 12。
2.2 实例2
验证条件2,3：
-
package main
-
import "fmt"
-
-
func main() {
-
//第2、3条中的例子：
-
var slice = []int{1, 2, 3, 4, 5, 6, 7}
-
var slice1 = []int{8, 9}
-
fmt.Printf("slice %v len = %v cap = %v\n", slice, len(slice), cap(slice))
-
fmt.Printf("slice1 %v len = %v cap = %v\n", slice1, len(slice1), cap(slice1))
-
slice = append(slice, slice1...)
-
fmt.Printf("slice %v len = %v cap = %v\n", slice, len(slice), cap(slice))
-
}
输出：
-
[root@localhost test]# go run main.go
-
slice [1 2 3 4 5 6 7] len = 7 cap = 7
-
slice1 [8 9] len = 2 cap = 2
-
slice [1 2 3 4 5 6 7 8 9] len = 9 cap = 14
-
[root@localhost test]#
在实例2中，所需容量 cap = 7+2 = 9，原容量的两倍 doublecap = 2*7 = 14，原切片长度 old.len = 7，满足 <条件2,3>，即： 所需容量小于原容量的两倍，并且原切片长度 old.len 小于1024，所以，最终申请容量 newcap = doublecap = 14。
2.3 实例3
验证条件4：
-
package main
-
import "fmt"
-
-
func main() {
-
//第2条中的例子：
-
var slice []int
-
for i := 0; i < 1024; i++ {
-
slice = append(slice, i)
-
}
-
var slice1 = []int{1024, 1025}
-
fmt.Printf("slice %v len = %v cap = %v\n", slice, len(slice), cap(slice))
-
fmt.Printf("slice1 %v len = %v cap = %v\n", slice1, len(slice1), cap(slice1))
-
slice = append(slice, slice1...)
-
fmt.Printf("slice %v len = %v cap = %v\n", slice, len(slice), cap(slice))
-
}
输出：
-
[root@localhost test]# go run main.go
-
slice [0 1 2 3 4 5 6……1017 1018 1019 1020 1021 1022 1023] len = 1024 cap = 1024
-
slice1 [1024 1025] len = 2 cap = 2
-
slice [0 1 2 3 4 5 6……1017 1018 1019 1020 1021 1022 1023 1024 1025] len = 1026 cap = 1280
-
[root@localhost test]#
在实例3中，所需容量 cap = 1024+2 = 1026，doublecap = 2048, old.len = 1024，满足 <条件4> ，所以，newcap = 1024 + 1024/4 = 1280。
文章来源: blog.csdn.net，作者：Linux猿，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/nyist_zxp/article/details/111425091
- 点赞
- 收藏
- 关注作者
评论（0）