聊聊内存中的Slice操作

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

创新互联公司长期为1000多家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为麻山企业提供专业的成都做网站、网站设计，麻山网站改版等技术服务。拥有10多年丰富建站经验和众多成功案例,为您定制开发。

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

环境

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

声明

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

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

代码清单

 
 
 
 
    
  
  
  
  
  1. package main
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. import "fmt"
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. func main() {
    6. 
  
  
  
  
  6.     var src = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    7. 
  
  
  
  
  7.     src[3] = 100
    8. 
  
  
  
  
  8.     //src[13] = 200
    9. 
  
  
  
  
  9.     dst := makeSlice()
    10. 
  
  
  
  
  10.     makeSliceCopy(src)
    11. 
  
  
  
  
  11.     growSlice(src)
    12. 
  
  
  
  
  12.     copySlice(dst, src)
    13. 
  
  
  
  
  13.     sliceStringCopy([]byte("hello world"), "hello slice")
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. //go:noinline
    17. 
  
  
  
  
  17. func sliceStringCopy(slice []byte, s string) {
    18. 
  
  
  
  
  18.     copy(slice, s)
    19. 
  
  
  
  
  19.     PrintInterface(string(slice))
    20. 
  
  
  
  
  20. }
    21. 
  
  
  
  
  21. 
  
  
  
  
  22. //go:noinline
    23. 
  
  
  
  
  23. func copySlice(dst []int, src []int) {
    24. 
  
  
  
  
  24.     copy(dst, src)
    25. 
  
  
  
  
  25.     PrintInterface(dst)
    26. 
  
  
  
  
  26. }
    27. 
  
  
  
  
  27. 
  
  
  
  
  28. //go:noinline
    29. 
  
  
  
  
  29. func growSlice(slice []int) {
    30. 
  
  
  
  
  30.     slice = append(slice, 11)
    31. 
  
  
  
  
  31.     PrintInterface(slice)
    32. 
  
  
  
  
  32. }
    33. 
  
  
  
  
  33. 
  
  
  
  
  34. //go:noinline
    35. 
  
  
  
  
  35. func makeSliceCopy(array []int) {
    36. 
  
  
  
  
  36.     slice := make([]int, 5)
    37. 
  
  
  
  
  37.     copy(slice, array)
    38. 
  
  
  
  
  38.     PrintInterface(slice)
    39. 
  
  
  
  
  39. }
    40. 
  
  
  
  
  40. 
  
  
  
  
  41. //go:noinline
    42. 
  
  
  
  
  42. func makeSlice() []int {
    43. 
  
  
  
  
  43.     slice := make([]int, 5)
    44. 
  
  
  
  
  44.     //slice := make([]int, 5, 10)
    45. 
  
  
  
  
  45.     //slice := make([]int, 10, 5) // "len larger than cap in make(%v)"
    46. 
  
  
  
  
  46.     return slice
    47. 
  
  
  
  
  47. }
    48. 
  
  
  
  
  48. 
  
  
  
  
  49. //go:noinline
    50. 
  
  
  
  
  50. func PrintInterface(v interface{}) {
    51. 
  
  
  
  
  51.     fmt.Println("it =", v)
    52. 
  
  
  
  
  52. }
    53.

深入内存

1. 元素赋值

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

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

 
 
 
 
    
  
  
  
  
  1. src[13] = 200
    2.

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

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

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

2. make

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

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

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

 
 
 
 
    
  
  
  
  
  1. func makeslice(et *_type, len, cap int) unsafe.Pointer {
    2. 
  
  
  
  
  2.     // 计算需要分配的内存字节数
    3. 
  
  
  
  
  3.     mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    4. 
  
  
  
  
  4.     if overflow || mem > maxAlloc || len < 0 || len > cap {
    5. 
  
  
  
  
  5.         mem, overflow := math.MulUintptr(et.size, uintptr(len))
    6. 
  
  
  
  
  6.         if overflow || mem > maxAlloc || len < 0 {
    7. 
  
  
  
  
  7.             panicmakeslicelen()
    8. 
  
  
  
  
  8.         }
    9. 
  
  
  
  
  9.         panicmakeslicecap()
    10. 
  
  
  
  
  10.     }
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     // 直接分配内存
    13. 
  
  
  
  
  13.     return mallocgc(mem, et, true)
    14. 
  
  
  
  
  14. }
    15.

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

(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伪代码，大意如下：

 
 
 
 
    
  
  
  
  
  1. func copySlice(dst []int, src []int) {
    2. 
  
  
  
  
  2.     n := len(dst)
    3. 
  
  
  
  
  3.     if n  > len(src) {
    4. 
  
  
  
  
  4.         n = len(src)
    5. 
  
  
  
  
  5.     }
    6. 
  
  
  
  
  6.     if &dst[0] != &src[0] {
    7. 
  
  
  
  
  7.         runtime.memmove(&dst[0], &src[0], len(dst)*8)
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9.     PrintInterface(dst)
    10. 
  
  
  
  
  10. }
    11.

仔细阅读以上指令代码，确定其逻辑与 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伪代码，大意如下：

 
 
 
 
    
  
  
  
  
  1. func growSlice(slice []int) {
    2. 
  
  
  
  
  2.     if len(slice) + 1 > cap(slice) {
    3. 
  
  
  
  
  3.         slice = runtime.growslice(element_type_pointer, slice, 11)
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5.     // cap(slice) == 20
    6. 
  
  
  
  
  6.     slice[len(slice)] = 17
    7. 
  
  
  
  
  7.     PrintInterface(slice)
    8. 
  
  
  
  
  8. }
    9.

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

在本例中，

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

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

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

文章名称：聊聊内存中的Slice操作
本文路径：http://www.shufengxianlan.com/qtweb/news1/18351.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

搜索引擎优化知识

分类信息网

400电话申请　　 　雅安做网站　　 　仿古建筑设计　　 　成都定制高级网站建设　　 　网站制作　　 　手机APP开发　　 　成都标识标牌设计制作　　 　崇州湖霆科技　　 　主机租用　　 　节能环保网站建设方案　　 　ssl数字证书　　 　平昌做网站　　 　成都名片印刷　　 　温江网站建设　　 　邛崃网站建设　　 　LED显示屏厂家　　 　四川搅拌罐车　　 　服务器租用　　 　橡塑保温板　　 　网站设计制作报价