并发基础
并发包含如下几种主流的实现模型：
- 多进程
- 多线程
- 基于回到的非阻塞/异步IO
- 协程
协程
与传统的系统级线程和进程相比，协程最大的优势在于“轻量级”，可以轻松创建上百万个而不会导致系统资源枯竭，而线程和进程通常最多不超过1万个。
Golang在语言级别支持协程，叫goroutine。
goroutine
goroutine是Golang中轻量级线程的实现，由Go运行时管理，使用go关键字来触发一个新的goroutine执行。
具体来说，在一个函数调用前加上关键字go，这次调用就会在一个新的goroutine中并发执行。
当被调用的函数返回时，这个goroutine也自动结束了。需要注意的是：如果这个函数有返回值，那么这个返回值会被丢弃。
func Add(a, b int) {
z := a + b
fmt.Println("z=", z)
}
func main() {
for i := 0; i < 10; i++ {
go Add(1, 1) // 在函数调用前使用关键字go，使得函数的调用是在goroutine中执行
}
}
上述代码演示了如何在Golang中使用goroutine。
但是上述代码运行时并没有任何输出！原因：Go程序从初始化main package并执行main()函数开始，当main()函数返回时，程序退出，且程序并不会等待其他goroutine（非主goroutine）结束。
并发通信
在工程上，有2种最常见的并发通信模型：共享数据和消息。
被共享的数据可能有多种形式，如：内存数据块，磁盘文件，网络数据等。
如果是通过共享内存来实现并发通信，那就只能使用锁了。
Golang以并发编程作为语言的最核心优势，提供了另一种通信模型，即：以消息机制而非共享内存作为并发通信方式。
Golang提供的消息机制被称为channel。
channel
channel是Golang在语言级别提供的goroutine间通信方式，可以使用channel在两个或多个goroutine之间传递消息。
channel是进程内的通信方式，因此通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。
channel是类型相关的，即：一个channel只能传递一种类型的值，这个类型需要在声明channel时指定。
基本语法
一般channel的声明形式为：
// 与声明一般变量的不同在于需要在类型前面加了关键字chan
// ElementType指定这个channel所能传递的元素类型
var chanName chan ElementType
示例：
// 声明一个传递类型为int的channel
var ch chan int
// 声明一个map，元素类型为bool的channel，即：这个channel传递的元素类型为map，map的值类型为bool
var m map[string] chan bool
定义一个channel也很简单，使用内置的函数make()即可：
// 声明并初始化了一个传递类型为int的channel
ch := make(chan int)
在channel的用法中，最常见的包括写入和读取。
将一个数据写入channel的语法：ch <- value，向channel写入数据通常会导致程序阻塞，直到有其他goroutine从这个channle中读取数据。
从channel中读取数据的语法是：value := <- ch，如果channel之前没有写入数据，那么从channel读取数据也会导致程序阻塞，直到channel中被写入数据为止。
select
Golang在语言级别支持select关键字，用于处理异步IO问题。
select与用法结构如下：
select {
case <-ch1:
// 如果从ch1成功读取到数据，执行该case处理语句
case ch2 <- 1:
// 如果成功向ch2写入数据，执行该case处理语句
default:
// 如果上面都没有成功，则进入default处理流程
}
在select的用法中，要求：每个case语句都必须是一个面向channel的操作。
如下是基于select的一段有趣的代码：
c := 0
ch := make(chan int, 1)
for {
// 使用select随机向ch中写入0或1
select {
case ch <- 0:
case ch <- 1:
}
i := <-ch
fmt.Println("Received: ", i)
c++
if c > 10 {
break
}
}
缓冲机制
不带缓冲的channel，对于传递单个数据的场景可以接受，但是对于需要传递大量数据的场景就不合适了。
创建一个带缓冲的channel：
// 在调用make()时将缓冲区大小作为第二个参数传入即可
c := make(chan int, 1024)
带缓冲区的channel即使没有读取方，写入方也可以一直往channel中写入数据，在缓冲区填满之前都不会阻塞。
从带缓冲区的channel中读取数据可以使用与常规非缓冲channel完全一致的方法，但是也可以使用range关键字来实现更简便的循环读取。
// 使用range关键字来实现带缓冲区channel的循环读取
for v := range ch {
fmt.Println("Received:", v)
}
超时机制
如果不能很好地处理超时问题，可能会导致goroutine永远阻塞而没有挽回的机会！
Golang中没有提供直接的超时处理机制，但是可以使用select很方便地解决超时问题（因为select的特点是只要其中一个case已经完成，程序就会继续往下执行，而不会考虑其他case的情况）。
ch := make(chan int, 1024)
// 首先，实现并执行一个匿名的超时等待函数
timeout := make(chan bool, 1)
go func() {
time.Sleep(1e9) // 等待一秒钟
timeout <- true
}()
// 然后，把timeout这个channel利用起来
select {
case <-ch:
// 从目标channel中读取数据
case <-timeout:
// 如果从目标channel中一直没有读取到数据，但是从timeout这个channel上读取到了数据
// 这样就使用select机制可以避免永久等待的问题
// 这是在Golang开发中避免channel通信超时的最有效办法
}
channel的传递
在Golang中channel本身也是一种原生类型，与map之类的类型地位一样，因此channel本身在定义后也可以通过channel来传递。
可以使用这个特性来实现管道，管道也是使用非常广泛的一种设计模式。
type PipeData struct {
value int
handler func(int) int
next chan int
}
首先限定一个基本的数据结构PipeData，然后写一个常规的处理函数。只要定义一系列PipeData的数据结构并一起传递给这个函数，就可以达到流式处理数据的目的。
func handle(queue chan *PipeData) {
for data := range queue {
data.next <- data.handler(data.value)
}
}
单向channel
单向channel只能用于发送或接收数据。
可以在将一个channel变量传递给一个函数时，通过指定其为单向channel变量，从而限制在该函数中可以对此channel执行的操作，比如只能往这个channel写，或者只能从这个channel读。
单向channel的声明非常简单，如下：
var ch1 chan int // ch1是一个正常的channel，不是单向的
var ch2 chan<- float64 // ch2是一个用于只写float64数据单项channel
var ch3 <-chan int // ch3是一个用于只读int数据的channel
单向channel的初始化：
ch4 := make(chan int)
ch5 := <-chan int(ch4) // ch5是一个单向读取的channel
ch6 := chan<- int(ch4) // ch6是一个单向写入的channel
如上，基于一个正常的channel可以实现单向channel的初始化。
即类型转换对于channel的意义：在单向channel和双向channel之间进行转换。
使用单向channel可以起到一种契约的作用：
func parse(ch <-chan int) {
for value := range ch {
fmt.Println("Received:", value)
}
}
如上，除非这个函数的实现者使用了类型转换，否则这个函数就不会因为各种原因而对ch变量执行写操作，因而避免在ch中出现非期望的数据，从而很好地实践最小权限原则。
关闭channel
使用内置函数close()关闭channel。
close(ch)
如何判断一个channel是否已经关闭？可以通过在读取的时候使用多重返回值进行判断：
// 使用多重返回值检查channel是否已经关闭
val, ok := <-ch
if ok {
// channel未关闭，可以正常使用返回值
fmt.Println("Received:", val)
}
多核并行化
多核并行化是指尽量利用CPU多核特性来将任务并行化执行。
具体到Golang中，就是要知道CPU核心的数量，并针对性地将计算任务分解到多个goroutine中并行运行。
// 获取CPU核心数量
runtime.NumCPU()
出让时间片
使用runtime.Gosched()在每个goroutine中控制何时主动出让时间片给其他goroutine。
同步
同步锁
Golang的sync包中提供了两种锁类型：sync.Mutex和sync.RWMutex。
Mutex是最简单的锁类型，同时也比较暴力，当一个goroutine获得Mutex后，其他goroutine就只能等待这个goroutine释放该Mutex。
RWMutex相对友好，是经典的单写多读模型。在读锁占用的情况下，会阻止写，但不阻止读。也就是多个goroutine可同时获取读锁，而写锁会阻止任何其他goroutine进来，整个锁相当于由该goroutine独占。获取读锁：sync.RWMutex.RLock()，获取写锁：sync.RWMutex.Lock()。
对于这两种锁类型，任何一个Lock()或RLock()均需要保证对应有Unlock()或RUnlock()调用与之对应，否则可能导致等待该锁的所有goroutine处于饥饿状态，甚至可能导致死锁。
锁的典型使用模式如下：
// 先声明一个锁
var lock sync.Mutex
func foo() {
lock.Lock()
defer lock.Unlock() // defer关键字的方便之处
// 获得锁之后需要执行的操作
}
全局唯一性操作
对于从全局的角度只需要运行一次的代码，比如全局初始化，Golang提供了一个Once类型来保证全局的唯一性操作。
var a string
var once sync.Once
func setup() {
a = "Hello, World!"
fmt.Println("初始化a")
}
func doPrint() {
once.Do(setup) // 使用Once来控制函数在全局角度只会执行一次
fmt.Println(a)
}
func twoPrint() {
go doPrint()
go doPrint()
}
如上示例代码，once的Do()方法可以保证在全局范围内只调用指定的函数一次，而且其他所有goroutine在调用到此语句时，将会先被阻塞，直到全局唯一的once.Do()调用结束之后才继续。
原子性操作
如果Golang中没有提供Once类型来保证全局唯一性操作，对于那些需要控制在全局只执行一次的操作来说，只能通过别的办法来处理了。
// 设置一个全局变量表示初始化操作是否完毕
var done bool = false
func setup() {
a = "Hello, World!"
done = true
fmt.Println("初始化a")
}
func doPrint() {
if !done {
setup()
}
fmt.Println(a)
}
这段代码看起来合理，但是细看还是会有问题，因为setup()并不是一个原子性操作。这种写法可能会导致setup()被调用多次，从而无法达到全局只执行一次的目标。
为了更好地控制并行中的原子性操作，sync包中还包含了一个atomic子包，它提供了对于一些基础数据类型的原子操作函数。
// 比较和交换2个uint64类型数据
func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)
有了这些原子操作函数，开发者就无需再为这样的操作专门添加Lock控制。
总结
关于Golang中并发编程有如下总结。
1.核心内容：协程
2.重要的关键字：chan，go，select，defer。