Golang slice map channel 小技巧

Slice vs Array

Slice 和 Array 是不同的类型

查看具体汇编代码
go tool compile -N -l main.go
go tool objdump main.o

Slice 的自动扩容
Slice 可以使用 append 函数新增数据，当容量不足的时候，会自动新申请一块空间，将原有数据复制过去，再新增数据。
https://github.com/golang/go/blob/2ebe77a2fda1ee9ff6fd9a3e08933ad1ebaea039/src/runtime/slice.go#L125

**当 cap < 1024 的时候，每次 *2 **
当 cap >= 1024 的时候，每次 * 1.25
其中还会涉及内存对齐的调整

var s []int == nil
高效的 append
​
func BenchmarkAppendSlice(b *testing.B) {
   for i := 0; i < b.N; i++ {
      s := make([]int, 0, 10000)
      for j := 0; j < 10000; j++ {
         s = append(s, j)
      }
   }
}
​
func BenchmarkAppendSliceIndexed(b *testing.B) {
   for i := 0; i < b.N; i++ {
      s := make([]int, 10000)
      for j := 0; j < 10000; j++ {
         s[j] = j
      }
   }
}

BenchmarkAppendSlice-12                   110247             10832 ns/op
BenchmarkAppendSliceIndexed-12            137204              8585 ns/op

因为 append 操作内部会每次去检查容量是不是够，即每次调用 runtime.growslice  ，下面为截取的部分汇编。
MOVQ AX, 0x50(SP)       
 LEAQ 0(IP), SI          [3:7]R_PCREL:type.int   
 MOVQ SI, 0(SP)          
 MOVQ BX, 0x8(SP)        
 MOVQ AX, 0x10(SP)       
 MOVQ DX, 0x18(SP)       
 MOVQ CX, 0x20(SP)       
 NOPL 0(AX)              
 CALL 0x5d6              [1:5]R_CALL:runtime.growslice<1>        
 MOVQ 0x28(SP), BX       
 MOVQ 0x30(SP), AX       
 MOVQ 0x38(SP), DX       
 LEAQ 0x1(AX), CX        
 MOVQ 0x50(SP), AX       
 JMP 0x57b

边界检查消除
边界检查消除 - Go语言101（通俗版Go白皮书）
func normal(s []int) int {
   i := 0
   
   i += s[0]
   i += s[1]
   i += s[2]
   i += s[3]
   i += s[4]
​
   return i
}
​
func bce(s []int) int {
   _ = s[4]
​
   i := 0
   i += s[0]
   i += s[1]
   i += s[2]
   i += s[3]
   i += s[4]
​
   return i
}

第一种情况下，golang 会在每一次按下标取值时调用 runtime.panicIndex 检查是否越界。
下面是截取的部分汇编：
下面的需要开启优化选项来编译  go tool compile   main.go

normal

CALL 0x8ce              [1:5]R_CALL:runtime.panicIndex  
MOVL $0x3, AX           
CALL 0x8d8              [1:5]R_CALL:runtime.panicIndex  
MOVL $0x2, AX           
NOPL                    
CALL 0x8e3              [1:5]R_CALL:runtime.panicIndex  
MOVL $0x1, AX           
CALL 0x8ed              [1:5]R_CALL:runtime.panicIndex  
XORL AX, AX             
CALL 0x8f4              [1:5]R_CALL:runtime.panicIndex


Bce

CALL 0xab8              [1:5]R_CALL:runtime.printint<1>         
CALL 0xabd              [1:5]R_CALL:runtime.printnl<1>          
CALL 0xac2              [1:5]R_CALL:runtime.printunlock<1>      
MOVQ 0x18(SP), BP       
ADDQ $0x20, SP          
RET                     
MOVL $0x3, AX           
CALL 0xad6              [1:5]R_CALL:runtime.panicIndex

总结

Golang 中 数组 和 slice 是两种完全不同的类型，也有着不同的行为

数组的不可改变，是其类型声明的一部分


Slice 本质是一个 struct，包含一个执行数据地址的指针，len 字段记录长度，cap 字段记录容量
Golang 中函数传参

如果是 slice ，则会复制内部的三个字段值来初始化一个新的 slice 变量


如果是 array，则会重新申请一块内存，复制整个数组的内容到新的 array 变量
*如果在函数内部 append 这个 slice，一定要传递 []int
Slice 的 append 函数内部会每次都调用 runtime.growslice ，检查是否需要扩容，在容量已经确定的情况下，用 index 更高效。
边界检查优化

Map
Map 主要是要了解一些源码实现，详情可以看下面的文章分析
深度解密Go语言之map | qcrao
总结

Map 删除 key 不会缩容，也不会释放空间
Map 的 key value 都不可取值
Map 内部和 slice 类似，都是用指针指向具体存储，所以用 map 作为函数参数，在函数内部可以修改 map

不同的是，如果在函数内部 map 发生扩容，是会作用于外部的 map 的，因为 map 内部采用拉链法，不同于 slice 的申请一个新空间然后复制过去


Map 非并发安全，并发访问使用 sync.Map

Channel
深度解密Go语言之channel | qcrao
总结

Channel 内部使用锁实现
Channel 会触发调度
Channel 发送的数据是值拷贝的，有必要的话需要传指针减少复制开销
For 循环里面的 select 内部的 break 只会跳出 select