附录A:Go语言常见坑

这里列举的Go语言常见坑都是符合Go语言语法的,可以正常的编译,但是可能是运行结果错误,或者是有资源泄漏的风险。

可变参数是空接口类型

当参数的可变参数是空接口类型时,传入空接口的切片时需要注意参数展开的问题。

  1. func main() {
  2. var a = []interface{}{1, 2, 3}
  3. fmt.Println(a)
  4. fmt.Println(a...)
  5. }

不管是否展开,编译器都无法发现错误,但是输出是不同的:

  1. [1 2 3]
  2. 1 2 3

数组是值传递

在函数调用参数中,数组是值传递,无法通过修改数组类型的参数返回结果。

  1. func main() {
  2. x := [3]int{1, 2, 3}
  3. func(arr [3]int) {
  4. arr[0] = 7
  5. fmt.Println(arr)
  6. }(x)
  7. fmt.Println(x)
  8. }

必要时需要使用切片。

map遍历是顺序不固定

map是一种hash表实现,每次遍历的顺序都可能不一样。

  1. func main() {
  2. m := map[string]string{
  3. "1": "1",
  4. "2": "2",
  5. "3": "3",
  6. }
  7. for k, v := range m {
  8. println(k, v)
  9. }
  10. }

返回值被屏蔽

在局部作用域中,命名的返回值内同名的局部变量屏蔽:

  1. func Foo() (err error) {
  2. if err := Bar(); err != nil {
  3. return
  4. }
  5. return
  6. }

recover必须在defer函数中运行

recover捕获的是祖父级调用时的异常,直接调用时无效:

  1. func main() {
  2. recover()
  3. panic(1)
  4. }

直接defer调用也是无效:

  1. func main() {
  2. defer recover()
  3. panic(1)
  4. }

defer调用时多层嵌套依然无效:

  1. func main() {
  2. defer func() {
  3. func() { recover() }()
  4. }()
  5. panic(1)
  6. }

必须在defer函数中直接调用才有效:

  1. func main() {
  2. defer func() {
  3. recover()
  4. }()
  5. panic(1)
  6. }

main函数提前退出

后台Goroutine无法保证完成任务。

  1. func main() {
  2. go println("hello")
  3. }

通过Sleep来回避并发中的问题

休眠并不能保证输出完整的字符串:

  1. func main() {
  2. go println("hello")
  3. time.Sleep(time.Second)
  4. }

类似的还有通过插入调度语句:

  1. func main() {
  2. go println("hello")
  3. runtime.Gosched()
  4. }

独占CPU导致其它Goroutine饿死

Goroutine是协作式抢占调度,Goroutine本身不会主动放弃CPU:

  1. func main() {
  2. runtime.GOMAXPROCS(1)
  3. go func() {
  4. for i := 0; i < 10; i++ {
  5. fmt.Println(i)
  6. }
  7. }()
  8. for {} // 占用CPU
  9. }

解决的方法是在for循环加入runtime.Gosched()调度函数:

  1. func main() {
  2. runtime.GOMAXPROCS(1)
  3. go func() {
  4. for i := 0; i < 10; i++ {
  5. fmt.Println(i)
  6. }
  7. }()
  8. for {
  9. runtime.Gosched()
  10. }
  11. }

或者是通过阻塞的方式避免CPU占用:

  1. func main() {
  2. runtime.GOMAXPROCS(1)
  3. go func() {
  4. for i := 0; i < 10; i++ {
  5. fmt.Println(i)
  6. }
  7. os.Exit(0)
  8. }()
  9. select{}
  10. }

不同Goroutine之间不满足顺序一致性内存模型

因为在不同的Goroutine,main函数中无法保证能打印出hello, world:

  1. var msg string
  2. var done bool
  3. func setup() {
  4. msg = "hello, world"
  5. done = true
  6. }
  7. func main() {
  8. go setup()
  9. for !done {
  10. }
  11. println(msg)
  12. }

解决的办法是用显式同步:

  1. var msg string
  2. var done = make(chan bool)
  3. func setup() {
  4. msg = "hello, world"
  5. done <- true
  6. }
  7. func main() {
  8. go setup()
  9. <-done
  10. println(msg)
  11. }

msg的写入是在channel发送之前,所以能保证打印hello, world

闭包错误引用同一个变量

  1. func main() {
  2. for i := 0; i < 5; i++ {
  3. defer func() {
  4. println(i)
  5. }()
  6. }
  7. }

改进的方法是在每轮迭代中生成一个局部变量:

  1. func main() {
  2. for i := 0; i < 5; i++ {
  3. i := i
  4. defer func() {
  5. println(i)
  6. }()
  7. }
  8. }

或者是通过函数参数传入:

  1. func main() {
  2. for i := 0; i < 5; i++ {
  3. defer func(i int) {
  4. println(i)
  5. }(i)
  6. }
  7. }

在循环内部执行defer语句

defer在函数退出时才能执行,在for执行defer会导致资源延迟释放:

  1. func main() {
  2. for i := 0; i < 5; i++ {
  3. f, err := os.Open("/path/to/file")
  4. if err != nil {
  5. log.Fatal(err)
  6. }
  7. defer f.Close()
  8. }
  9. }

解决的方法可以在for中构造一个局部函数,在局部函数内部执行defer:

  1. func main() {
  2. for i := 0; i < 5; i++ {
  3. func() {
  4. f, err := os.Open("/path/to/file")
  5. if err != nil {
  6. log.Fatal(err)
  7. }
  8. defer f.Close()
  9. }()
  10. }
  11. }

切片会导致整个底层数组被锁定

切片会导致整个底层数组被锁定,底层数组无法释放内存。如果底层数组较大会对内存产生很大的压力。

  1. func main() {
  2. headerMap := make(map[string][]byte)
  3. for i := 0; i < 5; i++ {
  4. name := "/path/to/file"
  5. data, err := ioutil.ReadFile(name)
  6. if err != nil {
  7. log.Fatal(err)
  8. }
  9. headerMap[name] = data[:1]
  10. }
  11. // do some thing
  12. }

解决的方法是将结果克隆一份,这样可以释放底层的数组:

  1. func main() {
  2. headerMap := make(map[string][]byte)
  3. for i := 0; i < 5; i++ {
  4. name := "/path/to/file"
  5. data, err := ioutil.ReadFile(name)
  6. if err != nil {
  7. log.Fatal(err)
  8. }
  9. headerMap[name] = append([]byte{}, data[:1]...)
  10. }
  11. // do some thing
  12. }

空指针和空接口不等价

比如返回了一个错误指针,但是并不是空的error接口:

  1. func returnsError() error {
  2. var p *MyError = nil
  3. if bad() {
  4. p = ErrBad
  5. }
  6. return p // Will always return a non-nil error.
  7. }

内存地址会变化

Go语言中对象的地址可能发生变化,因此指针不能从其它非指针类型的值生成:

  1. func main() {
  2. var x int = 42
  3. var p uintptr = uintptr(unsafe.Pointer(&x))
  4. runtime.GC()
  5. var px *int = (*int)(unsafe.Pointer(p))
  6. println(*px)
  7. }

当内存发生变化的时候,相关的指针会同步更新,但是非指针类型的uintptr不会做同步更新。

同理CGO中也不能保存Go对象地址。

Goroutine泄露

Go语言是带内存自动回收的特性,因此内存一般不会泄漏。但是Goroutine确存在泄漏的情况,同时泄漏的Goroutine引用的内存同样无法被回收。

  1. func main() {
  2. ch := func() <-chan int {
  3. ch := make(chan int)
  4. go func() {
  5. for i := 0; ; i++ {
  6. ch <- i
  7. }
  8. } ()
  9. return ch
  10. }()
  11. for v := range ch {
  12. fmt.Println(v)
  13. if v == 5 {
  14. break
  15. }
  16. }
  17. }

上面的程序中后台Goroutine向管道输入自然数序列,main函数中输出序列。但是当break跳出for循环的时候,后台Goroutine就处于无法被回收的状态了。

我们可以通过context包来避免这个问题:

  1. func main() {
  2. ctx, cancel := context.WithCancel(context.Background())
  3. ch := func(ctx context.Context) <-chan int {
  4. ch := make(chan int)
  5. go func() {
  6. for i := 0; ; i++ {
  7. select {
  8. case <- ctx.Done():
  9. return
  10. case ch <- i:
  11. }
  12. }
  13. } ()
  14. return ch
  15. }(ctx)
  16. for v := range ch {
  17. fmt.Println(v)
  18. if v == 5 {
  19. cancel()
  20. break
  21. }
  22. }
  23. }

当main函数在break跳出循环时,通过调用cancel()来通知后台Goroutine退出,这样就避免了Goroutine的泄漏。