并发（concurrency）不是并行（parallelism）。并行是让不同的代码片段同时在不同的处理器上执行。并行的关键是同时做很多事情，而并发是同时管理很多事情，这些事情可能只做了一半就被暂停去做别的事情了。在很多情况下，并发的效果要比并行好，因为操作系统和硬件的总资源一半很少，但能支持系统同时做很多事情。——《Go in Action》

参考了

《Go in Action》

《理解 Go 语言中的 select 用法》

1. WaitGroup

WaitGroup是一个计数信号量，可以用来记录并运行维护运行的goroutine，如果WaitGroup的值大于0，程序就会在调用Wait方法时阻塞。

要减少WaitGroup的值，就需要在执行goroutine后，调用WaitGroup对象的Done方法（最好使用defer来调用）

Add操作，可以给WaitGroup对象增加计数值。

2. runtime

• runtime.GOMAXPROCS()函数 可以更改调度器可以使用的逻辑处理器的数量
• runtime.NumCPU()函数可以获得物理处理器的数量
• Gosched()函数可以使得当前goroutine退出线程，并放回到队列

3. 竞争（race condition）

竞争状态：两个或多个goroutine在没有相互同步的情况下，访问某个共享资源，并试图对这个资源进行同时的读和写操作，就会处于相互竞争的状态。

3.1atomic包

• AddInt64() 强制同一时刻只能有一个goroutine对变量进行加法操作
• LoadInt64() 同一时刻只能有一个goroutine对变量进行读取操作
• StoreInt64 同一时刻只能有一个goutine对变量进行写入操作

3.2互斥锁（mutex）

互斥锁用于在代码上建立一个临界区，保证同一时间只能有一个goroutine来执行这个临界区的代码。

• Lock()
• Unlock()

3.3通道

3.3.1 创建通道

// 无缓冲通道
unbuffered := make(chan int)

// 有缓冲通道
buffered := make(chan string, 10)

3.3.2 通道的使用

• <channel> <- <varable> 向通道发送数据
• <varable> <- <channel> 从通道接受数据
• close(chan) 关闭通道，通道关闭后。不能再向通道内发送数据，但是可以从通道读取数据
• ball, ok := <- court 其中变量ok用来判断通道是否关闭

3.3.2.1 无缓冲的通道（unbuffered channel）

有缓冲的通道要求发送goroutine和接收goroutine同时准备好，才能完成发送和接收操作，如果两个goroutine没有同时准备好，就会导致阻塞等待。

3.3.2.2 有缓冲的通道（buffered channel）

有缓冲的通道是一种在被接手前能存储一个或者多个值的通道。与无缓冲通道不同的是，只有在通道中没有要接受的值时，接受动作才会阻塞；只有在通道没有可用缓冲区的时候，发送动作才会阻塞。因此，无缓冲通道保证进行发送和接收的goroutine会在同一时间进行数据交换；有缓冲的通道则无法保证

3.3.2.3 无缓冲通道与容量为1的有缓冲通道区别

其实两者的区别在两者的定义中已经说得很清楚了，主要就是无缓冲区通道需要接收方和发送方都准备好了，才会进行数据的收发工作，如果两者没有同时准备好，那么就会进行阻塞等待。具体的差异可以看下面两段代码：

package main

import "fmt"

func main(){
    ch := make(chan int)
    ch <- 1
    fmt.Println(<- ch)
}

package main

import "fmt"

func main() {
    ch := make(chan int, 1)
    ch <- 1
    fmt.Println(<- ch)
}

当执行第一段代码时，系统会报错

fatal error: all goroutines are asleep - deadlock!

而第二段代码就不会出现任何问题。

3.3.3 select语句

3.3.3.1 基本概念

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。

如果没有 case 可运行，它将阻塞，直到有 case 可运行。如果一直没有case可运行，就会抛出deadlock错误，因此一般最好有一个default的可选择项（default可以为空），例如

package main

import (
    "fmt"
)

func main() {
    c1 := make(chan string, 1)
    c2 := make(chan string, 1)

    select {
        case msg1 := <-c1:
            fmt.Println("c1 received: ", msg1)
        case msg2 := <-c2:
            fmt.Println("c2 received: ", msg2)
    }
}

执行上述代码就会报deadlock错误。要解决这个问题，大致有两种方法：

• 添加default语句
• 向channel中注入数据

3.3.3.2 select的超时

如前所述，如果select中既没有default，又始终没有收到相关的信号，就会进入阻塞。为了更精准的设置阻塞时间，我们可以利用一些小技巧来实现：

package main

import (
    "fmt"
    "time"
)

func makeTimeout(ch chan bool, t int) {
    time.Sleep(time.Second * time.Duration(t))
    ch <- true
}

func main() {
    c1 := make(chan string, 1)
    c2 := make(chan string, 1)
    timeout := make(chan bool, 1)

    go makeTimeout(timeout, 2)

    select {
    case msg1 := <-c1:
        fmt.Println("c1 received: ", msg1)
    case msg2 := <-c2:
        fmt.Println("c2 received: ", msg2)
    case <-timeout:
        fmt.Println("Timeout, exit.")
    }
}