Go语言高级编程-第99章 附录

Go语言高级编程系列是我读《Go语言高级编程》时的一些要点总结。

  1. 当参数的可变参数是空接口类型时，传人空接口的切片时需要注意参数展开的问题。
1
2
3
4
5
func main() {
var a=[]interface{}{1, 2, 3}
      fmt.Println(a)
      fmt.Println(a...)
}

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

1
2
[1 2 3] 
123

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

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

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

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

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

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

  3. Goroutine是协作式抢占调度，Goroutine本身不会主动放弃CPU，可以在for循环加入runtime.Gosched()调度函数:

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

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

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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()
            }()
        }
    }

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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
    }

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

  6. 空指针和空接口不等价。比如返回了一个错误指针，但是并不是空的error接口:

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

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

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

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

  8. Goroutine泄露

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    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包来避免这个问题:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    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的泄漏。

  9. 随机数的一个特点是不好预测。如果一个随机数的输出是可以简单预测的，那么一般会称为伪随机数

golang
#读书
Go语言高级编程-第99章 附录
https://nrbackback.github.io/2021/12/04/Go语言高级编程-第99章 附录/
作者
John Doe
发布于
2021年12月4日
许可协议