使用遇到的问题_必读干货：使用Go语言常遇到的问题

这里列举的使用Go语言常遇到的问题都是符合Go语言语法的，可以正常编译，但是可能出现运行结果错误，或者是有资源泄漏的风险。

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

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

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

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

[1 2 3]1 2 3

A.2　数组是值传递

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

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

必要时需要使用切片。

A.3　map遍历时顺序不固定

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

func main() {    m := map[string]string{        "1": "1",        "2": "2",        "3": "3",    }    for k, v := range m {        println(k, v)    }}

A.4　返回值被屏蔽

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

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

A.5　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() {        recover()    }()    panic(1)}

A.6　main()函数提前退出

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

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

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

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

func main() {    go println("hello")    time.Sleep(time.Second)}

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

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

A.8　独占CPU导致其他Goroutine饿死

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

func main() {    runtime.GOMAXPROCS(1)    go func() {        for i := 0; i < 10; i++ {            fmt.Println(i)        }    }()    for {} // 占用CPU}

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

func main() {    runtime.GOMAXPROCS(1)    go func() {        for i := 0; i < 10; i++ {            fmt.Println(i)        }    }()    for {        runtime.Gosched()    }}

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

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

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

因为在不同的Goroutine，main()函数中无法保证能打印出“hello, world”：

var msg stringvar done boolfunc setup() {    msg = "hello, world"    done = true}func main() {    go setup()    for !done {    }    println(msg)}

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

var msg stringvar done = make(chan bool)func setup() {    msg = "hello, world"    done 

msg的写入是在通道发送之前，所以能保证打印“hello, world”。

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

下面的代码最终将输出相同的值：

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

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

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

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

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

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

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

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：

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()        }()    }}

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

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

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}

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

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] = append([]byte{}, data[:1]...)    }    // do some thing}

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

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

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

A.14　内存地址会变化

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对象地址。

A.15　Goroutine泄漏

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

func main() {    ch := func() 

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

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

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

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

本文摘自《Go语言高级编程》柴树杉，曹春晖 著。

• Go语言进阶实战，CGO编程web编程书
• 云计算云存储区块链时代重要编程语言
• 满足Gopher好奇心的Go语言进阶读物

本书聚焦于主流Go语言书中缺失的或刻意回避的部分主题，主要面向希望深入了解Go语言，特别是对Go语言和其他语言的混合编程、Go汇编语言的工作机制、构造Web框架和分布式开发等领域感兴趣的学生、工程师和研究人员。阅读本书需要读者对Go语言有一定的认识和使用经验。

本书关于CGO编程和Go汇编语言的讲解在中国乃至全球Go语言出版物中是非常有特色的。

本书主要内容● Go语言演化历史。● CGO编程技术。● Go汇编语言。● RPC和gRPC。● 构造Web框架的方法。● 分布式系统。