聊聊内存中的Slice操作

本文主要关注 slice 的相关操作：

1. 元素赋值(修改)
2. make
3. copy
4. make and copy
5. append

环境

OS : Ubuntu 20.04.2 LTS; x86_64 
Go : go version go1.16.2 linux/amd64 

声明

操作系统、处理器架构、Golang版本不同，均有可能造成相同的源码编译后运行时内存地址、数据结构不同。

本文仅保证学习过程中的分析数据在当前环境下的准确有效性。

代码清单

package main 
 
import "fmt" 
 
func main() { 
    var src = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
    src[3] = 100 
    //src[13] = 200 
    dst := makeSlice() 
    makeSliceCopy(src) 
    growSlice(src) 
    copySlice(dst, src) 
    sliceStringCopy([]byte("hello world"), "hello slice") 
} 
 
//go:noinline 
func sliceStringCopy(slice []byte, s string) { 
    copy(slice, s) 
    PrintInterface(string(slice)) 
} 
 
//go:noinline 
func copySlice(dst []int, src []int) { 
    copy(dst, src) 
    PrintInterface(dst) 
} 
 
//go:noinline 
func growSlice(slice []int) { 
    slice = append(slice, 11) 
    PrintInterface(slice) 
} 
 
//go:noinline 
func makeSliceCopy(array []int) { 
    slice := make([]int, 5) 
    copy(slice, array) 
    PrintInterface(slice) 
} 
 
//go:noinline 
func makeSlice() []int { 
    slice := make([]int, 5) 
    //slice := make([]int, 5, 10) 
    //slice := make([]int, 10, 5) // "len larger than cap in make(%v)" 
    return slice 
} 
 
//go:noinline 
func PrintInterface(v interface{}) { 
    fmt.Println("it =", v) 
} 

深入内存

1. 元素赋值

该操作很简单，直接通过偏移量定位元素内存并赋值，对应一条机器指令：

如果如下元素索引超过runtime.slice.cap, 则会panic。

src[13] = 200 

查看可执行程序，Golang编译器发现代码异常之后，直接使用runtime.panicIndex函数调用替换了元素赋值及之后的所有操作，退出程序。

这很令人好奇：明明编译时期发现了代码逻辑错误，但并没有终止编译过程，而是把它变成一个运行时异常。难道运行时异常更好吗?

针对这个问题暂时没有找到合理的答案，只能猜测这是编译器为了应对各种代码场景的一个通用编译处理逻辑，而不是仅仅为了处理本例中的情况。

2. make

使用make关键字动态创建 slice。编译之后make会变成什么指令，视情况而定。

代码清单中第42行的makeSlice函数编译之后，对应的机器指令如下：

可以看到，make关键字编译之后，变成了 runtime.makeslice 函数调用，其实现如下：

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 { 
        mem, overflow := math.MulUintptr(et.size, uintptr(len)) 
        if overflow || mem > maxAlloc || len < 0 { 
            panicmakeslicelen() 
        } 
        panicmakeslicecap() 
    } 
 
    // 直接分配内存 
    return mallocgc(mem, et, true) 
} 

以上代码非常简单，有几个判断条件稍微解释下：

(1)overflow表示元素大小和元素数量的乘积是否溢出，即是否大于64位无符号整数的最大值，肯定是不能大于的;

(2)maxAlloc的值为 0x1000000000000，实际上大多数64位处理器和操作系统的内存可寻址范围并不是64位，而是不超过48位，这是Golang一个内存分配和校验逻辑;

(3)len>cap时，Golang编译器会进行检查 ，编译失败。

另外，在Golang源码中，有个 runtime.makeslice64 函数，并没有出现在编译后的可执行程序中。在 Go 编译器代码中看到应该是和32位程序编译相关。我们更关心64位程序，所以不再深究。

3. copy

代码清单中第23行的copySlice函数编译之后，对应的机器指令如下：

将其翻译为Golang伪代码，大意如下：

func copySlice(dst []int, src []int) { 
    n := len(dst) 
    if n  > len(src) { 
        n = len(src) 
    } 
    if &dst[0] != &src[0] { 
        runtime.memmove(&dst[0], &src[0], len(dst)*8) 
    } 
    PrintInterface(dst) 
} 

仔细阅读以上指令代码，确定其逻辑与 runtime.slicecopy 函数相匹配，也就是说copy关键字编译之后变成了runtime.slicecopy函数调用。但是编译器对runtime.slicecopy函数进行了内联优化，所以最终并不能看到直接的runtime.slicecopy函数调用。

在Golang中，copy关键字可以用于把 string 对象拷贝到[]byte对象中;因为字符串类型还没有学习到，所以暂时搁置这种特殊情况。

4. make and copy

当make和copy两个关键字一起使用时，又发生了新变化。

代码清单中第35行的makeSliceCopy函数编译之后，对应的机器指令如下：

可以清楚的看到，当make和copy两个关键字一起使用时，被Golang编译器合并成了 runtime.makeslicecopy 函数调用。该函数源代码逻辑非常清晰，此处不再赘述。

5. append

代码清单中第29行的growSlice函数对已经满的 slice 进行 append 操作。

编译之后，对应的机器指令如下：

以上代码逻辑是：首先进行len(slice)+1和cap(slice)比较，对已经满的 slice 进行 append 操作时，将触发底层数组的长度扩增(分配新的数组)，将其翻译为Golang伪代码，大意如下：

func growSlice(slice []int) { 
    if len(slice) + 1 > cap(slice) { 
        slice = runtime.growslice(element_type_pointer, slice, 11) 
    } 
    // cap(slice) == 20 
    slice[len(slice)] = 17 
    PrintInterface(slice) 
} 

runtime.growslice 函数的功能是：slice 进行append操作时，如果该slice已经满了，调用该函数重新分配底层数组进行扩容。

在本例中，

1. 原 slice 的容量是10，调用runtime.growslice函数之后，容量变为20。
2. slice元素是 int 类型(element_type_pointer)，关于该类型的分析可以阅读内存中的整数 。

通过以上学习研究，对slice的各种操作有了本质上的了解，相信用起来更加得心应手。

本文转载自微信公众号「Golang In Memory」