深入理解go slice结构

文章

slice tricks

slice

array的语法： [4]int{1,2,3,4}, [...]int{1,2,3}。在go中array是值类型，这就意味着一个类型为array的变量名并不是一个指针，当传递值是，array总是被复制。

slice的语法： []int{1,2,3,4}, make([]int), make([]int,10)

当make只有两个参数时，cap和len相同。

slice本质上是array的一个片段的描述，它包含3部分：
[ptr, len, cap]

通过make([]int, 5)创建的slice，其内存布局如下：

对这个slice进行截断之后，形成新的slice：

使用cap可以对slice进行扩增： s[:cap(s)].

copy(dst, src []t) int的用法: copy会复制dst和src中长度最小的元素所对应的数量(所以如果dst==nil, 则copy返回0）。并且，copy还能处理dst和src存在重叠的情况。
用法：

t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t

append(dst []t, element...t) []t的实现，与下面的appendbyte类似：
首先检查容量，容量不足则使用make构造一个新的slice并将原来的元素移动。

func appendbyte(slice []byte, data ...byte) []byte {
    m := len(slice)
    n := m + len(data)
    if n > cap(slice) { // if necessary, reallocate
        // allocate double what's needed, for future growth.
        newslice := make([]byte, (n+1)*2)
        copy(newslice, slice)
        slice = newslice
    }
    slice = slice[0:n]
    copy(slice[m:n], data)
    return slice
}

slice对gc的影响(gotcha)

如果对一个很大的数组，取其中很小的一段切片，都会造成这个数组不会被gc回收。
gc使用mark-and-sweep(标记清除)。gc维护一个已分配的堆对象表，在标记阶段，它将寄存器，堆栈上的指针作为root进行遍历标记。

为什么部分slice会导致整体的array不会回收呢？设想下面的slice：

a := [4]int{0,1,2,3}
s := a[1:2] // {1}
return s

a会不会被回收呢？答案是不会，因为gc遍历s时，通过data指针找到对应的array切片，它发现这个地址在之前分配的一个array对象的范围内，从而标记这个array为可到达对象，避免其被整个清除。（这里所要理解的就是array是按范围标记的，并不是按指针头标记的，因为一个内存块对象是有范围的，如果被部分引用，说明整个对象仍然是可达的。）

如何解决？如果是这种情况，一个较大array返回较小切片，可以使用复制：

before：

var digitregexp = regexp.mustcompile("[0-9]+")

func finddigits(filename string) []byte {
    b, _ := ioutil.readfile(filename)
    return digitregexp.find(b)
}

after：

func copydigits(filename string) []byte {
    b, _ := ioutil.readfile(filename)
    b = digitregexp.find(b)
    c := make([]byte, len(b))
    copy(c, b)
    return c
}

reflect.sliceheader

package reflect

// sliceheader和stringheader具有相同的data和len，这导致[]byte可以直接转换成string，而不需要任何复制
type sliceheader struct {
	data uintptr
	len  int
	cap  int
}
type stringheader struct {
	data uintptr
	len  int
}

转换代码：

func slicebyteasstring(b []byte) string {
    return *(*string)(unsafe.pointer(&b))
}
func stringasslicebyte(s string) []byte {
    p := unsafe.pointer(&d)
    var b []byte
    hdr :=  (*reflect.sliceheader)(unsafe.pointer(&b))
    hdr.data = uintptr(p)
    hdr.cap = len(s)
    hdr.len = len(s)
    return b
}

func int64asbyteslice(d int64) []byte {
    p := unsafe.pointer(&d)
    var b []byte
    hdr :=  (*reflect.sliceheader)(unsafe.pointer(&b))
    hdr.data = uintptr(p)
    hdr.cap = 8
    hdr.len = 8
    return b
}

到此这篇关于go slice结构的文章就介绍到这了,更多相关go slice结构内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！