Go语言常见坑

可变参数是空接口类型

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

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

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

//fmt.Println(a)输出的是未解包的数组，
//而fmt.Println(a...)是已解包的数组
[1 2 3]
1 2 3

数组是值传递

在函数调用参数中，数组是值传递，无法通过修改数组类型的参数返回结果，切片是地址传递，必要时需要使用切片。

package main

import "fmt"

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

	y := []int{1, 2, 3}
	func(arr []int) {
		arr[0] = 7
		fmt.Println(arr) //[7 2 3]
	}(y)
	fmt.Println(y) //[7 2 3]
}

map遍历是顺序不固定

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

package main

import "fmt"

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

	for k, v := range m {
		fmt.Println(k, v)
	}
}

结果如下：map值得遍历是hash，并不是每次的值都是一样的

3 3
1 1
2 2

返回值被屏蔽

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

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

recover必须在defer函数中运行

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

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

直接defer调用也是无效：

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

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

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

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

func main() {
    defer func() {
        if err ：= recover();err != nil {
        	err.New("错误信息！");
        }
    }()
    panic(1)
}

main函数无法保证完成任务

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

func main() {
    go fmt.Println("hello")
}

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

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

func main() {
	go fmt.Println("hello world")
	time.Sleep(time.Nanosecond)
}

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

func main() {
    go fmt.Println("hello")
    runtime.Gosched()
}

独占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
}

解决的方法是在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()
	}
}

或者是通过阻塞的方式避免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 {}
}

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

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

package main

var msg string
var done bool

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

func main() {
	go setup()
	for !done {
		
	}
	println(msg)
}

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

package main

import "fmt"

var msg string
var done = make(chan bool)

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

func main() {
	go setup()
	<-done
	fmt.Println(msg)
}

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

闭包错误引用同一个变量

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

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

package main

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

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

package main

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

在循环内部执行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)
		}
		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)
			}
			defer f.Close()
		}()
	}
}

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

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

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)
		}
		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 := "/"
		data, err := ioutil.ReadFile(name)
		if err != nil {
			log.Fatal(err)
		}
		headerMap[name] = append([]byte{}, data[:1]...)
	}

	// do some thing
}

空指针和空接口不等价

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

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

内存地址会变化

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

func main() {
    var x int = 42
    var p uintptr = uintptr(unsafe.Pointer(&x))
    runtime.GC()
    var px *int = (*int)(unsafe.Pointer(p))
    println(*px)
}

当内存发送变化的时候，相关的指针会同步更新，但是非指针类型的uintptr不会做同步更新。
同理CGO中也不能保存Go对象地址。

Goroutine泄露

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

package main

import (
	"fmt"
)

func main() {
	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的泄漏。

变量的作用域

package main

import (
	"fmt"
)

var Ga = 99

const v = 199

func GetGa() func() int {

	if Ga := 55; Ga < 60 {
		fmt.Println("GetGa if 中：", Ga)
	}
	fmt.Println(Ga)
	for Ga := 2; ; {
		fmt.Println("GetGa循环中：", Ga)
		break
	}

	fmt.Println("GetGa函数中：", Ga)

	return func() int {
		Ga += 1
		return Ga
	}
}

func main() {
	Ga := "string"
	fmt.Println("main函数中：", Ga)

	b := GetGa()
	fmt.Println("main函数中：", b(), b(), b(), b())
	fmt.Println(v)
	v := 1
	{
		v := 2
		fmt.Println(v)
		{
			v := 3
			fmt.Println(v)
		}
	}
	fmt.Println(v)
}

运行结果：

main函数中： string
GetGa if 中： 55
全局变量Ga： 99
GetGa循环中： 2
GetGa函数中： 99
main函数中： 100 101 102 103
全局常量 v= 199
2
3
1

Ga作为全局变量纯在是int类型，值为99；而在main()中时，Ga通过简式声明 := 操作，是string类型，值为string。在main()中，v很典型地体现了在“{}”花括号中的作用域问题，每一层花括号，都是对上一层的屏蔽。而闭包函数，GetGa()返回的匿名函数，赋值给b，每次执行b()，Ga的值都被记忆在内存中，下次执行b()的时候，取b()上次执行后Ga的值，而不是全局变量Ga的值，这就是闭包函数可以使用包含它的函数内的变量，因为作为代码块一直存在，所以每次执行都是在上次基础上运行。

简单总结如下：

有花括号"{ }"一般都存在作用域的划分； := 简式声明会屏蔽所有上层代码块中的变量（常量），建议使用规则来规范，如对常量使用全部大写，而变量尽量小写； 在if等语句中存在隐式代码块，需要注意； 闭包函数可以理解为一个代码块，并且他可使用包含它的函数内的变量；

注意，简式变量只能在函数内部声明使用，但是它可能会覆盖函数外全局同名变量。而且你不能在一个单独的声明中重复声明一个变量，但在多变量声明中这是允许的，而且其中至少要有一个新的声明变量。重复变量需要在相同的代码块内，否则你将得到一个隐藏变量。 如果你在代码块中犯了这个错误，将不会出现编译错误，但应用运行结果可能不是你所期望。所以尽可能避免和全局变量同名。

package main

import "fmt"

func main() {
	if a := 1; false {
	} else if b := 2; false {
	} else if c := 3; false {
	} else {
		fmt.Println(a, b, c) //1 2 3
	}
}