教程集 > Golang编程 > golang教程 > 正文简单说说go语言Slice的底层实现

简单说说go语言Slice的底层实现

发布时间：2022-03-07 编辑：jiaochengji.com

教程集为您提供简单说说go语言Slice的底层实现等资源，欢迎您收藏本站，我们将为您提供最新的简单说说go语言Slice的底层实现资源

切片我的理解是,他是数组的一个片段,就是说他是数组上截取的一部分,它可以通过下标访问到具体的元素,也能在原数组中<code>自由活动</code>,当你往里面<code>append</code>新元素的时候,如果当前数组容量足够,还会修改原数组的值;如果容量不够了,它就会把原数组中的值拷贝到一个新的数组中(新数组的容量按扩容规则增加),然后新加的元素加入到新的数组中,此时切片的底层数组就不再是原来的数组了,这个时候,你修改切片中的值,原数组就不会发生变化,因为他们不再有关联了,只是对于使用者来说,我们察觉不到这个过程.

<h2>slice的创建</h2>

下面我们用几个普通的例子来试试创建<code>slice</code>

<pre><code class="lang-go hljs">func createSlice() { s := make([]int, 0) s = append(s, 1) fmt.Println(s) var s2 []int s2 = append(s2, 1) fmt.Println(s2) s3 := []int{} s3 = append(s3, 1) fmt.Println(s3) } /** 输出结果为: [1] [1] [1] */ </code></pre>

上面的例子还是很好理解的,那我们接下来看看这几种创建模式的差异:

<code>go tool compile -S main.go</code>使用上述命令,查看上面的代码在底层都做了些什么?

完整的返回我这边就不展示了,就展示关键的几行代码:

<pre><code> 0x0021 00033 (main.go:6) LEAQ type.int(SB), AX 0x0028 00040 (main.go:6) PCDATA $0, $0 0x0028 00040 (main.go:6) MOVQ AX, (SP) 0x002c 00044 (main.go:6) XORPS X0, X0 0x002f 00047 (main.go:6) MOVUPS X0, 8(SP) s := make([]int, 0) 0x0034 00052 (main.go:6) CALL runtime.makeslice(SB) ...... 0x003e 00062 (main.go:7) LEAQ type.int(SB), CX ...... s = append(s, 1) 0x005f 00095 (main.go:7) CALL runtime.growslice(SB) ...... 0x008c 00140 (main.go:8) CALL runtime.convTslice(SB) 这个为fmt.Println的具体实现,这里就不多说了 ============================================================ 0x00e7 00231 (main.go:11) LEAQ type.int(SB), AX ...... var s2 []int 0x019f 00415 (main.go:15) LEAQ runtime.zerobase(SB), AX ...... s2 = append(s2, 1) 0x010c 00268 (main.go:11) CALL runtime.growslice(SB) ...... 0x0139 00313 (main.go:12) CALL runtime.convTslice(SB) </code></pre>

从上面我们不难看出,不同的切片创建方法,底层做了不同的操作第一个是<code>runtime.makeslice</code>，第二个没有对应的实现，第三个是<code>runtime.zerobase</code>，这三种方式区别还是有的，但是最终都可以实现我们的目标，因为最终都是调用了<code>runtime.mallocgc</code> 函数，也就是分配内存，看到这有同学就会问了，第二种方式我们并没有对应的实现啊，也就是说并没有分配内存啊。是的，第二种方式我们确实没有直接分配内存，并且我们直接<code>append</code>了，其实是因为<code>append</code>操作会对没有分配内存的切片再分配一下内存（这个我们下面会说到）。所以我们在写代码时，使用 <code>var</code> 关键字声明切片是完全可以的，并且对于长度为0的切片我们非常建议这样声明。

现在我们先看下<code>runtime.makeslice</code>:

<pre><code class="lang-go hljs">// et为元素类型 func makeslice(et *_type, len, cap int) unsafe.Pointer { mem, overflow := math.MulUintptr(et.size, uintptr(cap)) if overflow || mem > maxAlloc || len < 0 || len > cap { // NOTE: Produce a 'len out of range' error instead of a // 'cap out of range' error when someone does make([]T, bignumber). // 'cap out of range' is true too, but since the cap is only being // supplied implicitly, saying len is clearer. // See golang.org/issue/4085. mem, overflow := math.MulUintptr(et.size, uintptr(len)) if overflow || mem > maxAlloc || len < 0 { panicmakeslicelen() } panicmakeslicecap() } return mallocgc(mem, et, true) } // 首先程序会根据你元素的大小以及容量做个计算(mem=size*cap)以及判断是否溢出,如果溢出了,或者大于了最大可分配的内存大小(与操作系统位数有关),以及长度小于0或者长度小于容量,就会报错.然后下面会再去判断具体是长度错误还是容量错误 // return mallocgc(mem, et, true) 才是真正去分配内存 </code></pre> <h2>slice的扩容</h2>

网上关于切片的扩容都是什么切片容量小于1024的时候,新切片的容量翻倍,大于1024之后,新切片的容量为旧容量的1.25倍,但是实际上真的是这样的吗?我们先看一段代码:

<pre><code class="lang-go hljs">slice := make([]int32,3,3) fmt.Println("len:", len(slice), "cap:", cap(slice)) slice = append(slice, 1) fmt.Println("len:", len(slice), "cap:", cap(slice)) fmt.Println(slice) /** 输出结果如下: len: 3 cap: 3 len: 4 cap: 8 [0 0 0 1] / </code></pre>

从上面的例子看好像并不是翻倍耶(我的同事说因为3 1=4 然后翻倍就变成了8,哈哈哈开个玩笑哈),那么这是怎么一回事呢?我们看看源码:

<pre><code class="lang-go hljs">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")) } 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 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 } } } var overflow bool var lenmem, newlenmem, capmem uintptr // Specialize for common values of et.size. // For 1 we don't need any division/multiplication. // For sys.PtrSize, compiler will optimize division/multiplication into a shift by a constant. // For powers of 2, use a variable shift. 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): 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.ptrdata == 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 lenmem > 0 && 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} } </code></pre>

从这里我们可以看出好像的确是按网上说的规则进行的扩容:

<pre><code class="lang-go hljs">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 } } } </code></pre>

在这里我们拿到了新的cap应该是6才对是吧,但是为什么就变成了8呢?我们继续往下看:

<pre><code class="lang-go hljs">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): 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) } </code></pre>

它会根据你元素的类型从新给你计算一下你的新容量,这个时候得到的新容量才是你切片的真正容量,所以即使你没超过1024,也不一定就是翻倍了,而是根据你的元素类型的计算的.(<code>int32</code>是4个字节的元素,在这里4个字节的元素计算起来较为麻烦,这里就不多叙述了,下面我用一个int类型的元素详细说说)

我们接下来再看个例子:(我的电脑是64位)

<pre><code class="lang-go hljs"> slice := make([]int64, 3,3) fmt.Println("len:", len(slice), "cap:", cap(slice)) // 3 3 slice = append(slice, 1) fmt.Println("len:", len(slice), "cap:", cap(slice))// 4 6 var a int64 fmt.Println(unsafe.Sizeof(a)) // 8 </code></pre>

这个时候就是翻倍了,我们按上面的说法计算一下试试:

<code>newcap := old.cap</code> =><code>newcap = 3</code>

</li><li>

<code>doublecap := newcap newcap</code> => <code>doublecap = 6</code>

</li><li>

<code>cap</code>为新切片的容量即:旧切片容量3 新<code>append</code>的1个元素=4

</li><li>

<code>cap < doublecap && old.len < 1024</code>所以<code>newcap = doublecap</code> => <code>newcap = 6</code>

</li><li>

由上我们可知<code>int64</code>为8位,我们现在再来这个<code>switch</code>语句中看看