4 函数¶

函数参数过多可以重构为一个符合类型结构，也算是变相实现可选参数和命名实参功能。

// Package main  provides ...
package main

import (
    "log"
    "time"
)

type serverOption struct {
    address string
    port    int
    path    string
    timeout time.Duration
    log     *log.Logger
}

func newOption() *serverOption {
    return &serverOption{
        address: "0.0.0.0",
        port:    8080,
        path:    "/var/test",
        timeout: time.Second * 5,
        log:     nil,
    }
}

func server(option *serverOption) {}
func main() {
    opt := newOption()
    opt.port = 8085
    server(opt)
}

闭包(closure)：是在其此法上下文中引用了自由变量的函数。或者说是函数和其引用的环境的组合体。本质上返回的是一个funcval 结构，可在 runtime/runtime2.go 找到定义。

package main

func test(x int) func() {
    return func() {
        println(x) //匿名函数引用了x
    }
}

func main() {
    f := test(123)
    f()
}

闭包通过指针引用环境变量，可能导致其生命周期延长，甚至被分配到堆内存。延迟求值特性。

package main

func test() []func() {
    var s []func()
    for i := 0; i < 2; i++ {
        s = append(s, func() {
            println(&i, i)
        })
    }
    return s
}

func main() {
    for _, f := range test() {
        f()
    }
}

输出格式:for循环复用局部变量i，每次添加的匿名函数引用的自然是同一变量。添加操作仅仅是把匿名函数放入列表，并未执行。当 main 执行这些函数时，读取的是环境变量 i 最后一次循环的值。

0xc00001a088 2
0xc00001a088 2

解决方式是每次用不同的环境变量或者传参复制，让各自的闭包环境各部相同。

func test() []func() {
    var s []func()
    for i := 0; i < 2; i++ {
        x := i
        s = append(s, func() {
            println(&x, x)
        })
    }
    return s
}

go 复古地使用了返回错误值（通常是最后一个值），大量函数和方法返回 error，会使得调用方比较难看，处理方式有：

使用专门的检查函数处理错误逻辑（比如记录日志），简化检查代码
在不影响逻辑的情况下，使用 defer 延后处理错误状态(err退化赋值)
在不中断逻辑的情况下，将错误作为内部状态保存，等最终提交时再处理。

panic, recover: 内置函数而非语句。panic 会立即中断当前函数流程，执行延迟调用。而在延迟调用函数中，recover 可捕获并返回 panic 提交的错误对象。连续调用 panic，仅最后一个会被 recover 捕获。在defer 函数中 panic，不会影响后续延迟调用的执行。而recover之后 panic，可被再次捕获。 recover必须在延迟调用函数中执行才能正常工作。

建议：除非是不可恢复性、导致系统无法正常工作的错误，否则不建议使用 panic。比如文件系统无权限、端口被占用、数据库未启动等。

// func panic(v interface{})
// func recover() interface{}
package main

import "log"

func main() {
    defer func() {
        if err := recover(); err != nil { //捕获错误
            log.Fatalln(err)
        }
    }()
    panic("I am dead")
    println("exit.") // 永不会执行
}



// Package main  provides ...
package main

func test(x, y int) {
    z := 0
    func() { //如果要保护代码片段，只能将其重构为函数调用。利用匿名函数保护"z=x/y"
        defer func() {
            if recover() != nil {
                z = 0
            }
        }()
        z = x / y
    }()
    println("x/y=", z)
}
func main() {
    test(5, 0)
}



//调试阶段可以用 runtime.debug.PrintStack 输出堆栈信息
package main

import "runtime/debug"

func test() {
    panic("i am dead")
}

func main() {
    defer func() {
        if err := recover(); err != nil {
            debug.PrintStack()
        }
    }()
    test()
}

5 数据¶

字符串¶

字符串操作通常在堆上分配内存，会对 web 等高并发场景造成交大影响，会有大量字符串对象要做垃圾回收。建议使用[]byte 缓存池活在栈上自行拼装实现 zero-garbage.

rune 用来存储unicode 码点(code point)，int32别名。单引号字面量默认类型就是rune.

数组¶

数组类型包含长度，元素类型相同但是长度不同也不是同一类型，无法比较。如果元素类型支持比较，数组也支持。数组是值类型，赋值或者传参都会复制整个数组数据。可以用指针或者切片。

切片 slice¶

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

slice 无法比较，只能判断是否为nil。可以用 slice 很容易实现栈

package main

import (
    "errors"
    "fmt"
)

func main() {
    // cap is 5
    stack := make([]int, 0, 5)

    // 入栈
    push := func(x int) error {
        n := len(stack)
        if n == cap(stack) {
            return errors.New("stack full")
        }
        stack = stack[:n+1]
        stack[n] = x
        return nil
    }

    // 出栈
    pop := func() (int, error) {
        n := len(stack)
        if n == 0 {
            return 0, errors.New("stack is empty")
        }
        x := stack[n-1]
        stack = stack[:n-1]
        return x, nil
    }

    for i := 0; i < 7; i++ {
        fmt.Printf("push %d: %v, %v\n", i, push(i), stack)
    }
    for i := 0; i < 7; i++ {
        x, err := pop()
        fmt.Printf("pop :%d, %v, %v\n", x, err, stack)
    }

}

append: append操作向切片尾部追加元素，返回新的切片对象。如果超出 cap限制，为新切片对象重新分配数组。向 nil 切片追加数据时，会为其分配底层数组。某些场合建议预留空间，防止重新分配。

package main

import "fmt"

func main() {
    s := make([]int, 0, 5)
    s1 := append(s, 10)
    s2 := append(s1, 20, 30)
    fmt.Println(s, len(s), cap(s)) //不会修改原slice属性
    fmt.Println(s1, len(s1), cap(s1))
    fmt.Println(s2, len(s2), cap(s2))

}

copy: 在两个切片对象之间复制数据，允许指向同一个底层数组，允许目标区间重叠。最终复制长度一较短的 slice 长度为准。

字典¶

key必须是支持相等运算符(==/!=) 的数据类型，比如数字、字符串、指针、数组、结构体以及对应的接口类型。字典是引用类型，使用 make函数或者初始化表达语句创建。对字典进行迭代，每次返回的键值对次序都不同。字典被设计成 “not addressable”，不能直接修改 value 成员（结构或数组）。正确的方式是返回整个 value，待修改后再设置字典键值或直接用指针类型。

package main

func main() {
    type user struct {
        name string
        age  byte
    }
    m := map[int]user{
        1: {"Tom", 19},
    }
    //m[1].age++ // wrong!!!

    u := m[1]
    u.age++
    m[1] = u

    m2 := map[int]*user{
        1: &user{"jack", 20},
    }

    m2[1].age++
}

在迭代期间删除或者新增键值是安全的。运行时会对字典并发操作做出检测，如果某个任务在对字典进行写操作，其他任务不能对其执行并发操作(读/写/删除)，否则会导致进程崩溃。可以用 sync.RWMutex 实现同步，避免读写同时进行。

结构 struct¶

struct 将多个不同类型的命名字段(field)序列打包成一个符合类型。字段名必须唯一，可以用 _ 补齐，支持使用自身指针类型的成员。

空结构可作为通道元素类型，用于事件通知。

package main

func main() {

    exit := make(chan struct{})

    go func() {
        println("hello")
        exit <- struct{}{}
    }()

    <-exit
    println("end.")
}

字段标签：对字段进行描述的元数据。不属于数据成员，但却是类型的组成部分。运行期间可以用反射获取类型信息。

package main

import (
    "fmt"
    "reflect"
)

type user struct {
    name string `昵称`
    sex  byte   `性别`
}

func main() {
    u := user{"Tom", 1}
    v := reflect.ValueOf(u)
    t := v.Type()

    for i, n := 0, t.NumField(); i < n; i++ {
        fmt.Printf("%s:%v\n", t.Field(i).Tag, v.Field(i))
    }
}

结构体分配内存时字段须做对齐处理。通常以所有字段中最长的基础类型宽度为准。

方法¶

方法是与对象实例绑定的特殊函数。可以为当前包，以及除了接口以外的任何类型定义方法。方法不支持重载。receiver 参数名没有限制，按惯例会选用简短有意义的名称，但不推荐用this/self。如果方法内部并不引用实例，可省略只保留类型。

package main

import "fmt"

type N int

func (n N) toString() string {
    return fmt.Sprintf("%#x", n)
}

func main() {
    var a N = 25
    println(a.toString())
}

类型有一个与之相关的方法集(method set)，决定了它是否实现某个接口。

方法和函数一样出了直接调用还可以赋值给变量、或者作为参数传递。按照具体引用方式不同，分为 expression/value 两种状态。

method expression: 通过类型引用的 method expression会被还原为普通函数样式，receiver是第一参数，调用时需要显示传参。
method value:基于实例或者指针引用的method value，参数签名不会改变，按照正常方式调用。但当method value被赋值给变量或者作为参数传递，会立即计算并复制该方法执行所需的receiver对象，与其绑定，以便稍后执行时，能隐式传入 receiver 参数。

7 接口¶

接口代表一种调用契约，是多个方法声明的集合。在某些动态语言里，接口（interface）也被称作协议（protocol）。准备交互的双方，共同遵守事先约定的规则，使得在无须知道对方身份的情况下进行协作。接口要实现的是做什么，而不关心怎么做，谁来做。接口最常见的使用场景，是对包外提供访问，或预留扩展空间。 Go接口实现机制很简洁，只要目标类型方法集内包含接口声明的全部方法，就被视为实现了该接口，无须做显示声明。当然，目标类型可实现多个接口。从内部实现来看，接口自身也是一种结构类型，只是编译器会对其做出很多限制。不能有字段;不能定义自己的方法;只能声明方法不能实现；可嵌入其他接口类型。

type iface struct {
    tab  *itab // 类型信息
    data unsafe.Pointer //实际对象指针
}

空接口类似于面向对象里的根类型Object，可被赋值为任何类型的对象。接口变量默认值是 nil。如果实现接口的类型支持，可做相等运算。超集接口变量可以隐式转换为子集，反过来不行。将对象赋值给接口变量时，会复制该对象注意只有当接口变量内部两个指针（itab，data）都为 nil时，接口才等于 nil。这个地方容易出 bug。

package main

import "log"

type TestError struct{}

func (*TestError) Error() string {
    return "error"
}

func test(x int) (int, error) {
    var err *TestError
    if x < 0 {
        err = new(TestError)
        x = 0
    } else {
        x += 100
    }
    return x, err // NOTE：这个 err 有类型的  ，应该明确返回 nil
}

func main() {
    x, err := test(100)
    if err != nil {
        log.Fatalln("err!=nil")
    }
    println(x)
}

类型转换：类型推断（type assertiong）可以把接口变量转换为原始类型，或者用来判断是否实现了某个更具体的接口类型。

package main

import (
    "fmt"
)

type data int

func (d data) String() string {
    return fmt.Sprintf("data:%d", d)
}

func main() {
    var d data = 15
    var x interface{} = d

    if n, ok := x.(fmt.Stringer); ok { // 转换为更具体的接口类型
        fmt.Println(n)
    }

    if d2, ok := x.(data); ok { // 转换回原始类型
        fmt.Println(d2)
    }

    e := x.(error) // 错误:main.data is not error
    fmt.Println(e)
}

8 并发¶

并发：逻辑上具备同时处理多个任务的能力
并行：物理上在同一时刻执行多个并发任务

使用 go 关键字就可以创建并发任务。go 并发执行并发操作，而是创建一个并发任务单元。新建任务被放置在系统队列中，等待调度器安排合适系统线程去获取执行权。 goroutine自定义栈仅需要2KB，自定义栈采用按需分配策略，需要时进行扩容。

和 defer 一样，goroutine也会因『延迟执行』而立即计算并复制执行参数。

package main

import "time"

var c int

func counter() int {
    c++
    return c
}

func main() {
    a := 100

    go func(x, y int) {
        time.Sleep(time.Second) //让gortouine在 main 逻辑之后执行
        println("go:", x, y)
    }(a, counter()) //立即计算并且复制参数
    a += 100
    println("main:", a, counter())

    time.Sleep(time.Second * 3) //等待goroutine 结束
}
// 注意输出：func()参数里的couter()会先计算
// main: 200 2
// go: 100 1

Wait:进程退出时不会等待并发任务结束，可用通道(channel)阻塞，然后发出退出信号。

package main

import "time"

func main() {
    exit := make(chan struct{})

    go func() {
        time.Sleep(time.Second)
        println("goroutine done.")
        close(exit) //关闭通道，发出信号
    }()

    println("main...")
    <-exit //如果通道关闭，立即解除阻塞
    println("main exit")
}

如果等待多个任务结束，推荐使用 sync.WaitGroup。通过设定计数器让每个goroutine 在退出之前递减，直到归零解除阻塞。

package main

import (
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)

        go func(id int) {
            //wg.Add(1)这里设置可能会来不及执行
            defer wg.Done()
            time.Sleep(time.Second)
            println("goroutine", id, "done.")
        }(i)
    }

    println("main...")
    wg.Wait()
    println("main exit.")
}

GOMAXPROCS: 运行时可能会创建很多线程，但是任何时候仅有限的几个线程参与并发任务执行。该数量默认和处理器核数相等，可用 runtime.GOMAXPROCS 函数或者环境变量修改。参数小于1仅返回当前设置值，不做任何调整。

LocalStorage: 与线程不同，goroutine任务无法设置优先级，无法获取编号，没有局部存储（TLS），甚至连返回值都会被抛弃。但除优先级外，其他功能都很容易实现。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var gs [5]struct {
        id     int
        result int
    }
    for i := 0; i < len(gs); i++ {
        wg.Add(1)
        go func(id int) { //使用参数避免闭包延迟求值
            defer wg.Done()
            gs[id].id = id
            gs[id].result = (id + 1) * 100
        }(i)
    }
    wg.Wait()
    fmt.Printf("%+v\n", gs)
}

Goshed: 暂停，释放线程去执行其他任务，当前任务被放回队列，等待下次调度时恢复执行。该函数很少被使用，因为运行时会主动向长时间运行（10 ms）的任务发出抢占调度。只是当前版本实现的算法稍显粗糙，不能保证调度总能成功，所以主动切换还有适用场合。

package main

import "runtime"

func main() {
    runtime.GOMAXPROCS(1)
    exit := make(chan struct{})

    go func() { //任务 a
        defer close(exit)

        go func() { //任务 b，放在此处为了确保 a 优先制行
            println("b")
        }()

        for i := 0; i < 4; i++ {
            println("a:", i)
            if i == 1 { //让出当前线程，调度执行b
                runtime.Gosched()
            }
        }
    }()

    <-exit
}

Goexit: Goexit立即终止当前任务，运行时确保所有已注册延迟调用被执行。该函数不会影响其他并发任务，不会引发panic，自然也就无法捕获。如果在main.main里调用Goexit，它会等待其他任务结束，然后让进程直接崩溃标准库函数os.Exit可终止进程，但不会执行延迟调用。

package main

import "runtime"

func main() {
    exit := make(chan struct{})

    go func() {
        defer close(exit)
        defer println("a")
        func() {
            defer func() {
                println("b", recover() == nil)
            }()

            func() {
                println("c")
                runtime.Goexit() //立即终止整个调用堆栈
                println("c done")
            }()
            println("b done")

        }()
        println("a done")
    }()
    <-exit
    println("main exit")
}
/*
c
b true
a
main exit
*/

通道：Go鼓励使用CSP通道，以通信来代替内存共享，实现并发安全。

Don’t communicate by sharing memory，share memory by communicating. CSP：Communicating Sequential Process.

通过消息来避免竞态的模型除了CSP，还有Actor。但两者有较大区别。

作为CSP核心，通道（channel）是显式的，要求操作双方必须知道数据类型和具体通道，并不关心另一端操作者身份和数量。可如果另一端未准备妥当，或消息未能及时处理时，会阻塞当前端。

除传递消息（数据）外，通道还常被用作事件通知。

相比起来，Actor是透明的，它不在乎数据类型及通道，只要知道接收者信箱即可。默认就是异步方式，发送方对消息是否被接收和处理并不关心。

package main

func main() {
    done := make(chan struct{}) //结束事件
    c := make(chan string)      // 数据传输通道

    go func() {
        s := <-c
        println(s)
        close(done) //关闭通道作为结束通知
    }()

    c <- "hi" //发送消息
    <-done    //阻塞直到有数据或者管道关闭
}

同步模式必须有配对操作的goroutine出现，否则会一直阻塞。而异步模式在缓冲区未满或数据未读完前，不会阻塞。

package main

import "fmt"

func main() {
    c := make(chan int, 3) //带有3个缓冲槽的异步通道
    c <- 1
    c <- 2

    fmt.Println(<-c)
    fmt.Println(<-c)
}

内置函数cap和len返回缓冲区大小和当前已缓冲数量；而对于同步通道则都返回0，据此可判断通道是同步还是异步。

package main

func main() {
    a, b := make(chan int), make(chan int, 3)
    b <- 1
    b <- 2
    println("a:", len(a), cap(a))
    println("b:", len(b), cap(b))
}

// a: 0 0
// b: 2 3

首发消息：除使用简单的发送和接收操作符外，还可用ok-idom或range模式处理数据。

package main

func main() {
    done := make(chan struct{})
    c := make(chan int)

    go func() {
        defer close(done)
        for {
            x, ok := <-c //判断通道是否关闭
            if !ok {
                return
            }
            println(x)
        }
        /*
        for x:= range c {  //  使用range 更方便点
            println(x)
        }
        */
    }()

    c <- 1
    c <- 2
    c <- 3
    close(c)
    <-done
}

// a: 0 0
// b: 2 3

对于closed或nil通道，发送和接收操作都有相应规则：

向已关闭通道发送数据，引发panic。
从已关闭接收数据，返回已缓冲数据或零值。
无论收发，nil通道都会阻塞。

package main

func main() { c := make(chan int, 3) c <- 10 c <- 20 close©
```
for i := 0; i < cap(c)+1; i++ {
    x, ok := <-c
    println(i, ":", ok, x)
}
```
} // 0 : true 10 // 1 : true 20 // 2 : false 0 // 3 : false 0

单向通道：通道默认是双向的，并不区分发送和接收端。但某些时候，我们可限制收发操作的方向来获得更严谨的操作逻辑。尽管可用make创建单向通道，但那没有任何意义。通常使用类型转换来获取单向通道，并分别赋予操作双方。

package main

import "sync"

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    c := make(chan int)
    var send chan<- int = c // 注意这里，send 通道
    var recv <-chan int = c

    go func() {
        defer wg.Done()
        for x := range recv {
            println(x)
        }
    }()

    go func() {
        defer wg.Done()
        defer close(c)

        for i := 0; i < 3; i++ {
            send <- i
        }
    }()
    wg.Wait()
}

选择：如要同时处理多个通道，可选用select语句。它会随机选择一个可用通道做收发操作。

package main

import "sync"

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    a, b := make(chan int), make(chan int)

    go func() {
        defer wg.Done()
        for {
            var (
                name string
                x    int
                ok   bool
            )
            select { //随机选择可用 channel 接收数据
            case x, ok = <-a:
                name = "a"
            case x, ok = <-b:
                name = "b"
            }
            if !ok { //如果任意一个通道关闭，终止接收
                return
            }
            println(name, x)
        }
    }()

    go func() { //发送端
        defer wg.Done()
        defer close(a)
        defer close(b)
        for i := 0; i < 10; i++ {
            select { //随机选择发送channel
            case a <- i:
            case b <- i * 10:
            }
        }
    }()
    wg.Wait()
}

如要等全部通道消息处理结束（closed），可将已完成通道设置为nil。这样它就会被阻塞，不再被select选中。

package main

import "sync"

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    a, b := make(chan int), make(chan int)

    go func() {
        defer wg.Done()
        for {
            select {
            case x, ok := <-a:
                if !ok {
                    a = nil //如果通道关闭设置为 nil，阻塞
                    break
                }
                println("a", x)
            case x, ok := <-b:
                if !ok {
                    b = nil
                    break
                }
                println("b", x)
            }
            if a == nil && b == nil { //全部结束退出循环
                return
            }
        }
    }()

    go func() { //发送端
        defer wg.Done()
        defer close(a)
        for i := 0; i < 3; i++ {
            a <- i
        }
    }()

    go func() { //发送端
        defer wg.Done()
        defer close(b)
        for i := 0; i < 5; i++ {
            b <- i * 10
        }
    }()

    wg.Wait()
}

当所有通道都不可用时，select会执行default语句。如此可避开select阻塞，但须注意处理外层循环，以免陷入空耗。

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan struct{})
    c := make(chan int)

    go func() {
        defer close(done)

        for {
            select {
            case x, ok := <-c:
                if !ok {
                    return
                }
                fmt.Println("data:", x)
            default: // 避免 select 阻塞
            }
            fmt.Println(time.Now())
            time.Sleep(time.Second) //避免空耗
        }
    }()
    time.Sleep(time.Second * 5)
    c <- 100
    close(c)
    <-done
}

也可用default处理一些默认逻辑。

package main

func main() {
    done := make(chan struct{})

    data := []chan int{ //缓冲数据区
        make(chan int, 3),
    }
    go func() {
        defer close(done)
        for i := 0; i < 10; i++ {
            select {
            case data[len(data)-1] <- i: //生产数据
            default: //当前通道已经满，生成新的缓存通道
                data = append(data, make(chan int, 3))
            }
        }
    }()
    <-done

    for i := 0; i < len(data); i++ {
        c := data[i]
        close(c)
        for x := range c {
            println(x)
        }
    }
}

模式: 通常使用工厂方法将goroutine和通道绑定。

package main

import "sync"

type receiver struct {
    sync.WaitGroup
    data chan int
}

func newReceiver() *receiver {
    r := &receiver{
        data: make(chan int),
    }

    r.Add(1)
    go func() {
        defer r.Done()
        for x := range r.data { // 接收消息，直到通道被关闭
            println("recv:", x)
        }
    }()

    return r
}

func main() {
    r := newReceiver()
    r.data <- 1
    r.data <- 2

    close(r.data) // 关闭通道，发出结束通知
    r.Wait()      // 等待接收者处理结束
}

用通道实现信号量（semaphore）。

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func main() {
    runtime.GOMAXPROCS(4)
    var wg sync.WaitGroup

    sem := make(chan struct{}, 2) // 最多允许2个并发同时执行

    for i := 0; i < 5; i++ {
        wg.Add(1)

        go func(id int) {
            defer wg.Done()

            sem <- struct{}{}        //acquire: 获取信号
            defer func() { <-sem }() //release: 释放信号

            time.Sleep(time.Second * 2)
            fmt.Println(id, time.Now())
        }(i)
    }

    wg.Wait()
}

性能:将发往通道的数据打包，减少传输次数，可有效提升性能。从实现上来说，通道队列依旧使用锁同步机制，单次获取更多数据（批处理），可改善因频繁加锁造成的性能问题。

资源泄漏:通道可能会引发goroutine leak，确切地说，是指goroutine处于发送或接收阻塞状态，但一直未被唤醒。垃圾回收器并不收集此类资源，导致它们会在等待队列里长久休眠，形成资源泄漏。

package main

import (
    "runtime"
    "time"
)

func test() {
    c := make(chan int)

    for i := 0; i < 10; i++ {
        go func() {
            <-c
        }()
    }
}

func main() {
    test()

    for {
        time.Sleep(time.Second)
        runtime.GC() // 强制垃圾回收
    }
}

// $go build-o test
// $GODEBUG="gctrace=1,schedtrace=1000,scheddetail=1" ./test

同步¶

通道并非用来取代锁的，它们有各自不同的使用场景。通道倾向于解决逻辑层次的并发处理架构，而锁则用来保护局部范围内的数据安全。标准库sync提供了互斥和读写锁，另有原子操作等，可基本满足日常开发需要。Mutex、RWMutex的使用并不复杂，只有几个地方需要注意。将Mutex作为匿名字段时，相关方法必须实现为pointer-receiver，否则会因复制导致锁机制失效。

应将Mutex锁粒度控制在最小范围内，及早释放。

// 错误用法
func doSomething() {
    m.Lock()
    url := cache["key"]
    http.Get(url) // 该操作并不需要锁保护
    m.Unlock()
}

// 正确用法
func doSomething() {
    m.Lock()
    url := cache["key"]
    m.Unlock() // 如使用defer，则依旧将Get保护在内
    http.Get(url)
}

Mutex不支持递归锁，即便在同一goroutine下也会导致死锁。

package main

import "sync"

func main() {
    var m sync.Mutex

    m.Lock()
    {
        m.Lock()
        m.Unlock()
    }
    m.Unlock()
}

对性能要求较高时，应避免使用defer Unlock。
读写并发时，用RWMutex性能会更好一些。
对单个数据读写保护，可尝试用原子操作。
执行严格测试，尽可能打开数据竞争检查。

9 包结构¶

依照规范，工作空间（workspace）由src、bin、pkg三个目录组成。通常需要将空间路径添加到GOPATH环境变量列表中，以便相关工具能正常工作。

GOPATH:编译器等相关工具按GOPATH设置的路径搜索目标。也就是说在导入目标库时，排在列表前面的路径比当前工作空间优先级更高。另外，go get默认将下载的第三方包保存到列表中第一个工作空间内。
GOROOT:环境变量GOROOT用于指示工具链和标准库的存放位置。在生成工具链时，相关路径就已经嵌入到可执行文件内，故无须额外设置。除通过设置GOROOT环境变量覆盖内部路径外，还可移动目录（改名、符号链接等），或重新编译工具链来解决。
GOBIN: 至于GOBIN，则是强制替代工作空间的bin目录，作为go install目标保存路径。这可避免将所有工作空间的bin路径添加到PATH环境变量中。

编译器从标准库开始搜索，然后依次搜索GOPATH列表中的各个工作空间。

import    "github.com/qyuhen/test"     默认方式:test.A
import X "github.com/qyuhen/test"     别名方式:X.A
import .  "github.com/qyuhen/test"     简便方式:A，不推荐使用在正式代码，一般测试中用
import _  "github.com/qyuhen/test"     初始化方式: 无法引用，仅用来初始化目标包

除工作空间和绝对路径外，部分工具还支持相对路径。可在非工作空间目录下，直接运行、编译一些测试代码。相对路径：当前目录，或以“./”和“../”开头的路径。不管是否在test目录下，只要命令行路径正确，就可用go build/run/test进行编译、运行或测试。但因缺少工作空间相关目录，go install会无法工作。在设置了GOPATH的工作空间中，相对路径会导致编译失败。go run不受此影响，可正常执行。

包（package）由一个或多个保存在同一目录下（不含子目录）的源码文件组成。包的用途类似名字空间（namespace），是成员作用域和访问权限的边界。包名和目录名并无关系，不要求一致。包名称通常单数形式。同一目录下所有源码文件必须使用相同包名称。因导入时使用绝对路径，所以在搜索路径下，包必须有唯一路径，但无须是唯一名字。

另有几个被保留、有特殊含义的包名称：

main：可执行入口（入口函数main.main）。
all：标准库以及GOPATH中能找到的所有包。
std，cmd：标准库及工具链。
documentation：存储文档信息，无法导入（和目录名无关）。

权限¶

所有成员在包内均可访问，无论是否在同一源码文件中。但只有名称首字母大写的为可导出成员，在包外可视。该规则适用于全局变量、全局常量、类型、结构字段、函数、方法等。可通过指针转换等方式绕开该限制。

初始化¶

包内每个源码文件都可定义一到多个初始化函数，但编译器不保证执行次序。实际上，所有这些初始化函数（包括标准库和导入的第三方包）都由编译器自动生成的一个包装函数进行调用，因此可保证在单一线程上执行，且仅执行一次。o 编译器首先确保完成所有全局变量初始化，然后才开始执行初始化函数。直到这些全部结束后，运行时才正式进入main.main入口函数。

内部包¶

在进行代码重构时，我们会将一些内部模块陆续分离出来，以独立包形式维护。此时，基于首字母大小写的访问权限控制就显得过于粗旷。因为我们希望这些包导出成员仅在特定范围内访问，而不是向所有用户公开。内部包机制相当于增加了新的访问权限控制：所有保存在internal目录下的包（包括自身）仅能被其父目录下的包（含所有层次的子目录）访问。

src/
|
+--main.go
|
+--lib/              # 内部包internal、a、b仅能被lib、lib/x、lib/x/y访问
|
+--internal/           # 内部包之间可相互访问
|      |
|      +--a/        # 可导入外部包，比如lib/x/y
|      |
|      +--b/
|
+--x/
    |
    +--y/

依赖管理¶

引入名为vendor的机制，专门存放第三方包，实现将源码和依赖完整打包分发。

src/
|
+--server/
|
+--vendor/
|     |
|     +--github.com/
|           |
|           +--qyuhen/
|                 |
|                 +--test/
+--main.go


// main.go
package main

import"github.com/qyuhen/test"

func main() {
test.Hello()
}

注意：vendor比标准库优先级更高。

当多个vendor目录嵌套时，如何查找正确目标？要知道引入的第三方包也可能有自己的vendor依赖目录。规则算不上复杂：从当前源文件所在目录开始，逐级向上构造vendor全路径，直到发现路径匹配的目标为止。匹配失败，则依旧搜索GOPATH。

要使用vendor机制，须开启“GO15VENDOREXPERIMENT=1”环境变量开关（Go 1.6默认开启），且必须是设置了GOPATH的工作空间。使用go get下载第三方包时，依旧使用GOPATH第一个工作空间，而非vendor目录。当前工具链中并没有真正意义上的包依赖管理，好在有不少第三方工具可选。

10 反射¶

反射（reflect）让我们能在运行期探知对象的类型信息和内存结构，这从一定程度上弥补了静态语言在动态行为上的不足。同时，反射还是实现元编程的重要手段。

和C数据结构一样，Go对象头部并没有类型指针，通过其自身是无法在运行期获知任何类型相关信息的。反射操作所需的全部信息都源自接口变量。接口变量除存储自身类型外，还会保存实际对象的类型数据。

func TypeOf(i interface{})Type
func ValueOf(i interface{})Value

这两个反射入口函数，会将任何传入的对象转换为接口类型。在面对类型时，需要区分Type和Kind。前者表示真实类型（静态类型），后者表示其基础结构（底层类型）类别。有一点和想象的不同，反射能探知当前包或外包的非导出结构成员。

可用反射提取struct tag，还能自动分解。其常用于ORM映射，或数据格式验证。

package main

import (
    "fmt"
    "reflect"
)

type user struct {
    name string `field:"name"type:"varchar(50)"`
    age  int    `filed:"age"type:"int"`
}

func main() {
    var u user
    t := reflect.TypeOf(u)

    for i := 0; i < t.NumField(); i++ {
        f := t.Field(i)
        fmt.Printf("%s: %s%s\n", f.Name, f.Tag.Get("field"), f.Tag.Get("type"))
    }
}
// name: namevarchar(50)
// age: int

值¶

和Type获取类型信息不同，Value专注于对象实例数据读写。

反射在带来“方便”的同时，也造成了很大的困扰。很多人对反射避之不及，因为它会造成很大的性能损失。

11 测试¶

单元测试（unit test）除用来测试逻辑算法是否符合预期外，还承担着监控代码质量的责任。任何时候都可用简单的命令来验证全部功能，找出未完成任务（验收）和任何因修改而造成的错误。它与性能测试、代码覆盖率等一起保障了代码总是在可控范围内，这远比形式化的人工检查要有用得多。

testing¶

工具链和标准库自带单元测试框架，这让测试工作变得相对容易。

测试代码须放在当前包以“_test.go”结尾的文件中。
测试函数以Test为名称前缀。
测试命令（go test）忽略以“_”或“.”开头的测试文件。
正常编译操作（go build/install）会忽略测试文件。

// main_test.go // go test -v package main

import “testing”

func add(x, y int) int { return x + y }

func TestAdd(t *testing.T) { if add(1, 2) != 3 { t.FailNow() } }

对于测试是否应该和目标放在同一目录，一直有不同看法。某些人认为应该另建一个专门的包用来存放单元测试，且只测试目标公开接口。好处是，当目标内部发生变化时，无须同步维护测试代码。每个人对于测试都有不同理解，就像覆盖率是否要做到90%以上，也是见仁见智。

table driven: 我们可用一种类似数据表的模式来批量输入条件并依次比对结果。

// main_test.go
// go test -v
package main

import "testing"

func add(x, y int) int {
    return x + y
}

func TestAdd(t *testing.T) {
    var tests = []struct {
        x      int
        y      int
        expect int
    }{
        {1, 1, 2},
        {2, 2, 4},
        {2, 3, 5},
    }

    for _, tt := range tests {
        actual := add(tt.x, tt.y)
        if actual != tt.expect {
            t.Errorf("add(%d, %d):expect%d,actual%d", tt.x, tt.y, tt.expect, actual)
        }
    }
}

test main:某些时候，须为测试用例提供初始化和清理操作，但testing并没有setup/teardown机制。解决方法是自定义一个名为TestMain的函数，go test会改为执行该函数，而不再是具体的测试用例。

func TestMain(m *testing.M) {
    //setup
    code := m.Run() // 调用测试用例函数
    //teardown
    os.Exit(code) // 注意：os.Exit不会执行defer
}

M.Run会调用具体的测试用例，但麻烦的是不能为每个测试文件写一个TestMain。要实现用例组合套件（suite），须借助MainStart自行构建M对象。通过与命令行参数相配合，即可实现不同测试组合。

func TestMain(m *testing.M) {
    match := func(pat, str string) (bool, error) { //pat: 命令行参数 -run提供的过滤条件 }}
        return true, nil //str:InternalTest.Name
    }

    tests := []testing.InternalTest{ // 用例列表，可排序
        {"b", TestB},
        {"a", TestA},
    }

    benchmarks := []testing.InternalBenchmark{}
    examples := []testing.InternalExample{}

    m = testing.MainStart(match, tests, benchmarks, examples)
    os.Exit(m.Run())
}

example: 例代码最大的用途不是测试，而是导入到GoDoc等工具生成的帮助文档中。它通过比对输出（stdout）结果和内部output注释是否一致来判断是否成功。

func ExampleAdd() {
    fmt.Println(add(1, 2))
    fmt.Println(add(2, 2))

    //Output:
    //3
    //4
}

如果没有output注释，该示例函数就不会被执行。另外，不能使用内置函数，print/println，因为它们输出到stderr。

性能测试¶

性能测试函数以Benchmark为名称前缀，同样保存在“*_test.go”文件里。

// main_test.go
// go test -bench .
package main

import "testing"

func add(x, y int) int {
    return x + y
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = add(1, 2)
    }
}

测试工具默认不会执行性能测试，须使用bench参数。它通过逐步调整B.N值，反复执行测试函数，直到能获得准确的测量结果。如果希望仅执行性能测试，那么可以用run=NONE忽略所有单元测试用例。默认就以并发方式执行测试，但可用cpu参数设定多个并发限制来观察结果。

timer: 如果在测试函数中要执行一些额外操作，那么应该临时阻止计时器工作。

func BenchmarkAdd(b *testing.B) {
    time.Sleep(time.Second)
    b.ResetTimer() // 重置

    for i := 0; i < b.N; i++ {
        _ = add(1, 2)

        if i == 1 {
            b.StopTimer() // 暂停
            time.Sleep(time.Second)
            b.StartTimer() // 恢复
        }
    }
}

memory:性能测试关心的不仅仅是执行时间，还包括在堆上的内存分配，因为内存分配和垃圾回收的相关操作也应计入消耗成本。

// go test -bench . -benchmem -gcflags "-N -l"  # 禁用内联和优化

package main

import "testing"

func heap() []byte {
    return make([]byte, 1024*10)
}

func BenchmarkHeap(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = heap()
    }
}

输出结果包括单次执行堆内存分配总量和次数。也可将测试函数设置为总是输出内存分配信息，无论使用benchmem参数与否。

func BenchmarkHeap(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        _ = heap()
    }
}

代码覆盖率¶

如果说单元测试和性能测试关注代码质量，那么代码覆盖率（code coverage）就是度量测试自身完整和有效性的一种手段。关键还是为改进测试提供一个可发现缺陷的机会，毕竟只有测试本身的质量得到保障，才能让它免于成为形式主义摆设。

12 工具链¶

自Go 1.5实现自举（bootstrapping）以后，我们就不得不保留两个版本的Go环境。对于初学者而言，建议先下载C版本的1.4，用GCC完成编译。自举是指用编译的目标语言编写其编译器，简单点说就是用Go语言编写Go编译器。请提前安装gcc、gdb、binutils等工具。

工具¶

go build: 此命令默认每次都会重新编译除标准库以外的所有依赖包。

参数          说明                 示例
------------------+-------------------------------------------+--------------
-o          可执行文件名（默认与目录同名）
-a          强制重新编译所有包（含标准库）
-p          并行编译所使用的CPU核数量
-v          显示待编译包名字
-n          仅显示编译命令，但不执行
-x          显示正在执行的编译命令
-work       显示临时工作目录，完成后不删除
-race       启动数据竞争检查（仅支持amd64）
-gcflags    编译器参数
-ldflags    链接器参数

gcflags：

参数说明示例 ------------------+-------------------------------------------+---------- -B 禁用越界检查 -N 禁用优化 -l 禁用内联 -u 禁用unsafe -S 输出汇编代码 -m 输出优化信息

ldflags：

参数说明示例 ------------------+-------------------------------------------+---------- -s 禁用符号表 -w 禁用DRAWF调试信息 -X 设置字符串全局变量值 -X ver=”0.99” -H 设置可执行文件格式 -H windowsgui

go install: 和build参数相同，但会将编译结果安装到bin、pkg目录。最关键的是，go install支持增量编译，在没有修改的情况下，会直接链接pkg目录中的静态包。编译器用buildid检查文件清单和导入依赖，对比现有静态库和所有源文件修改时间来判断源码是否变化，以此来决定是否需要对包进行重新编译。至于buildid算法，实现起来很简单：将包的全部文件名，运行时版本号，所有导入的第三方包信息（路径、buildid）数据合并后哈希。算法源码请阅读src/cmd/go/pkg.go。

go get: 将第三方包下载（check out）到GOPATH列表的第一个工作空间。默认不会检查更新，须使用“-u”参数。

go env: 显示全部或指定环境参数。

go clean: 清理工作目录，删除编译和安装遗留的目标文件。

编译¶

编译并不仅仅是执行“go build”命令，还有一些须额外注意的内容。如习惯使用GDB这类调试器，建议编译时添加-gcflags”-N-l”参数阻止优化和内联，否则调试时会有各种“找不到”的情况。

交叉编译: 所谓交叉编译（cross compile），是指在一个平台下编译出其他平台所需的可执行文件。自Go实现自举后，交叉编译变得更方便。只须使用GOOS、GOARCH环境变量指定目标平台和架构就行。

条件编译: 除在代码中用runtime.GOOS进行判断外，编译器本身就支持文件级别的条件编译。虽说没有C预编译指令那么方便，但是基于文件的组织方式更便于维护。

方法一：将平台和架构信息添加到主文件名尾部。
方法二：使用build编译指令。
方法三：使用自定义tag指令。

预处理：简单点说，就是用go generate命令扫描源码文件，找出所有“go：generate”注释，提取其中的命令并执行。

命令必须放在.go源文件中。
命令必须以“//go：generate”开头（双斜线后不能有空格）。
每个文件可有多条generate命令。
命令支持环境变量。
必须显式执行go generate命令。
按文件名顺序提取命令并执行。
串行执行，出错后终止后续命令的执行。