Go语言常见的坑

目录

• 1. 可变参数是空接口类型
• 2. 数组是值传递
• 3.map遍历是顺序不固定
• 4. 返回值被屏蔽
• 5.recover必须在defer函数中运行
• 6. main函数提前退出
• 7.通过Sleep来回避并发中的问题
• 8.独占CPU导致其它Goroutine饿死
• 9. 不同Goroutine之间不满足顺序一致性内存模型
• 10. 闭包错误引用同一个变量
• 11. 在循环内部执行defer语句
• 12. 切片会导致整个底层数组被锁定
• 13. 空指针和空接口不等价
• 14. 内存地址会变化
• 15.Goroutine泄露
• 16. append错误使用导致无返回值
• 17. append 可以追加nil值
• 不定期更新

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

1. 可变参数是空接口类型

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

package main

import "fmt"

func main() {
    var a = []interface{}{1, 2, 3}

    fmt.Println(a)
    fmt.Println(a...)
}

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

[1 2 3]
1 2 3

2. 数组是值传递

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

package main

import "fmt"

func main() {
	x := [3]int{1, 2, 3}

	// 匿名函数, 传入数组, 尝试通过数组索引修改数组
	func(arr [3]int) {
		arr[0] = 7
		fmt.Println("arr:", arr)
	}(x)

	fmt.Println("x:", x)
}

输出:

arr: [7 2 3]
x: [1 2 3]

必要时需要使用切片。

3.map遍历是顺序不固定

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

package main

import "fmt"

func main(){
    m := map[string]int{
        "1":1,
        "2":2,
        "3":3,
    }

    // 遍历字典k,v
    for k, v := range m {
        fmt.Println(k, v)
    }
}

每次执行结果,输出都不一样

输出:

3 3
1 1
2 2

4. 返回值被屏蔽

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

package main

import "fmt"

func Bar() error {
	return fmt.Errorf("func err Bar()... ")
}

func Foo() (err error) {
	if err := Bar(); err != nil {
		return
	}
	return
}

func main() {
	err := Foo()
	fmt.Printf("err is %v", err)
}

重新定义返回的变量名,导致输出错误, 输出

D:\gopath\src\Go_base\lesson\someNots>go run demo.go
# command-line-arguments
.\demo.go:11:3: err is shadowed during return

5.recover必须在defer函数中运行

1. recover捕获的是祖父级调用时的异常，直接调用时无效：

   package main
   
   func main() {
   	recover()
   	panic(1)
   }
   
   

   输出:

   panic: 1
   
   goroutine 1 [running]:
   main.main()
           D:/gopath/src/Go_base/lesson/someNotes/recover1.go:5 +0x4e
   exit status 2
   

2. 直接defer调用也是无效：

   package main
   
   func main() {
   	defer recover()
   	panic(1)
   }
   

   会提示:

   defer should not call recover() directly
   

3. defer调用时多层嵌套依然无效：

   package main
   
   func main() {
   	// 第一层匿名函数
   	defer func() {
   		// 第二层
   		func() {
   			recover()
   		}()
   	}()
   	panic(1)
   }
   

正确方式:

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

package main

import "fmt"

func main() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Printf("err:%v", err)
		}
	}()
	panic(1)
}

6. main函数提前退出

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

package main

func main() {
	go println("hello")
}

main函数相当于主线程, go启用单独的线程,无法满足 一致性

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

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

package main

import "time"

func main() {
	go func() {
		time.Sleep(time.Microsecond)
		println("hello, this is a goroutine")

	}()
	time.Sleep(time.Microsecond)
}

因为主线程于协程之间并不能满足一致性原则

8.独占CPU导致其它Goroutine饿死

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

package main

import (
	"fmt"
	"runtime"
)

func main() {
	runtime.GOMAXPROCS(1)

	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(i)
		}
	}()

	for {
	} // 占用CPU
}

结果会一直出于阻塞状态

解决办法

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

   package main
   
   import (
   	"fmt"
   	"runtime"
   )
   
   func main() {
   	runtime.GOMAXPROCS(1)
   
   	go func() {
   		for i := 0; i < 10; i++ {
   			fmt.Println(i)
   		}
   	}()
   
   	for {
   	    // 调度函数
   		runtime.Gosched()
   	}
   }
   

2. 通过阻塞的方式避免CPU占用：

   package main
   
   import (
   	"fmt"
   	"os"
   	"runtime"
   )
   
   func main() {
   	runtime.GOMAXPROCS(1)
   
   	go func() {
   		for i := 0; i < 10; i++ {
   			fmt.Println(i)
   		}
   		os.Exit(0)
   	}()
   
   	select {}
   }
   

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

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

package main

var msg string
var done bool

func setup() {
	msg = "hello, world"
	done = true
}

func main() {
	go setup()

	println(done)
	for !done {
	}
	println(msg)
}

输出:

false
hello, world

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

package main

import "fmt"

var msg string
var done = make(chan bool)

func setup() {
	msg = "hello, world"
	done <- true
}

func main() {
	go setup()
	// 无缓冲通道,写入优先于读取,所以当通道无数据时,会一直进行阻塞
	d := <-done
	fmt.Println(d)
	println(msg)
}

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

10. 闭包错误引用同一个变量

package main

func main() {
	for i := 0; i < 5; i++ {
	    // defer会压栈,只会存储最后一个变量值
		defer func() {
			println(i)
		}()
	}
}

输出:

5
5
5
5
5

改进:

1. 在每轮迭代中生成一个局部变量

   package main
   
   func main() {
   	for i := 0; i < 5; i++ {
   		i := i
   		// 输出刚好相反, 压栈先进后出
   		defer func() {
   			println(i)
   		}()
   	}
   }
   

2. 或者是通过函数参数传入：

   package main
   
   func main() {
   	for i := 0; i < 5; i++ {
   		defer func(i int) {
   			println(i)
   		}(i)
   	}
   }
   

3. 输出:

   4
   3
   2
   1
   0
   

11. 在循环内部执行defer语句

defer在*函数退出时才能执行**，所以直接在for循环内执行defer会导致资源延迟释放：

package main

import (
	"log"
	"os"
)

func main() {
	for i := 0; i < 5; i++ {
		f, err := os.Open("/path/to/file")
		if err != nil {
			log.Fatal(err)
		}
		// 会导致同时打开5个文档的操作句柄, 最后才会关闭
		defer f.Close()
	}
}

解决的方法:

在for中构造一个局部函数，在局部函数内部执行defer：

package main

import (
	"log"
	"os"
)

func main() {
	for i := 0; i < 5; i++ {
	    // 构建一个局部函数
		func() {
			f, err := os.Open("/path/to/file")
			if err != nil {
				log.Fatal(err)
			}
			// 函数执行完毕后,就可以直接执行 close操作
			defer f.Close()
		}()
	}
}

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

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

package main

import (
	"io/ioutil"
	"log"
)

func main() {
	headerMap := make(map[string][]byte)

	for i := 0; i < 5; i++ {
		name := "/path/to/file"
		// data是一个 byte数组
		data, err := ioutil.ReadFile(name)
		if err != nil {
			log.Fatal(err)
		}
		// map赋值时,对数组进行了切片
		headerMap[name] = data[:1]
	}

	// do some thing
}

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

package main

import (
	"io/ioutil"
	"log"
)

func main() {
	headerMap := make(map[string][]byte)

	for i := 0; i < 5; i++ {
		name := "/path/to/file"
		data, err := ioutil.ReadFile(name)
		if err != nil {
			log.Fatal(err)
		}

		// 将数组data切片后直接克隆一份儿
		headerMap[name] = append([]byte{}, data[:1]...)
	}

	// do some thing
}

13. 空指针和空接口不等价

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

func returnsError() error {
    var p *MyError = nil
    if bad() {
        p = ErrBad
    }
    return p // Will always return a non-nil error.
}

14. 内存地址会变化

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

package main

import (
	"runtime"
	"unsafe"
)

func main() {
	var x int = 42
	// p 为x的指针
	var p uintptr = uintptr(unsafe.Pointer(&x))

	runtime.GC()
	// 取地址
	var px *int = (*int)(unsafe.Pointer(p))
	println(*px)
}

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

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

15.Goroutine泄露

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

package main

import "fmt"

func main() {
	// 定义一个匿名函数, 返回一个只读int类型通
	ch := func() <-chan int {
		// 定义一个无缓冲读写通道
		ch := make(chan int)
		// 协程用于向通道写入数据
		go func() {
			for i := 0; ; i++ {
				ch <- i
			}
		}()
		return ch
	}()

	// 遍历结果
	for v := range ch {
		fmt.Println(v)
		if v == 5 {
			break
		}
	}
}

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

解决方法: 可以通过context包来避免这个问题：

package main

import (
	"context"
	"fmt"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())

	ch := func(ctx context.Context) <-chan int {
		ch := make(chan int)
		go func() {
			for i := 0; ; i++ {
				select {
				case <-ctx.Done():
					return
				case ch <- i:
				}
			}
		}()
		return ch
	}(ctx)

	for v := range ch {
		fmt.Println(v)
		if v == 5 {
			cancel()
			break
		}
	}
}

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

16. append错误使用导致无返回值

append的本质是向切片中追加数据，而随着切片中元素逐渐增加，当切片底层的数组将满时，切片会发生扩容.

如下：

函数Validation()用于一些合法性检查，每遇到一个错误，就生成一个新的error并追加到切片errs中，

最后返回包含所有错误信息的切片。

为了简单起见，假定函数发现了三个错误，如下所示：

func Validatior() []error {
    var errors []error

    append(errs, errors.New("error 1")
    append(errs, errors.New("error 2")
    append(errs, errors.New("error 3")
}

函数Validation()有什么问题？

目前有很多的工具可以自动检查出类似的问题，比如GolandIDE就会给出很明显的提示。但是并不知道为何出错。

append每个追加元素，都有可能触发切片扩容，也即有可能返回一个新的切片，这也是append函数声明中返回值为切片的原因。实际使用中应该总是接收该返回值。

上述题目一中，由于初始切片长度为0，所以实际上每次append都会产生一个新的切片并迅速抛弃（被gc回收）。

原始切片并没有任何改变。需要特别说明的是，不管初始切片长度为多少，不接收append返回都是有极大风险的。

所以正确的方式如下：

func Validatior() []error {
    var errs []error

    errs=append(errs, errors.New("error 1")
    errr=append(errs, errors.New("error 2")
    errs=append(errs, errors.New("error 3")
}

17. append 可以追加nil值

函数ValidateName()用于检查某个名字是否合法，如果不为空则认为合法，否则返回一个error。

类似的，还可以有很多检查项，比如检查性别、年龄等，我们统称为子检查项。

函数Validations()用于收集所有子检查项的错误信息，将错误信息汇总到一个切片中返回。

请问函数Validations()有什么问题？

func ValidateName(name string) error {
    if name != "" {
        return nil
    }

    return errors.New("empty name")
}

func Validations(name string) []error {
    var errs []error

    errs = append(errs, ValidateName(name))

    return errs
}

向切片中追加一个nil值是完全不会报错的，如下代码所示：

slice := append(slice, nil)

经过追加后，slice的长度递增1。

实际上nil是一个预定义的值，即空值，所以完全有理由向切片中追加。

单纯从技术上讲是没有问题，但在使用场景中就有很大的问题。

比如你可能会根据切片的长度来判断是否有错误发生，比如

func foo() {
    errs := Validations("")

    if len(errs) > 0 {
        println(errs)
        os.Exit(1)
    }
}

如果向切片中追加一个nil元素，那么切片长度则不再为0，程序很可能因此而退出，更糟糕的是，这样的切片是没有内容会打印出来的，这无疑又增加了定位难度.

不定期更新

...