目录：
Goroutine
在java中我们要实现并发编程的时候，通常要自己维护一个线程池，并且需要去包装任务、调度任务和维护上下文切换。这个过程需要消耗大量的精力。
Go语言中有一种机制，可以让系统自动把任务分配到CPU上实现并发执行，而不需要人工去管理这些任务。这就是goroutine。
Goroutine类似于线程，但比线程更轻量，可以称之为协程。它由运行时（runtime）调度和管理，自动进行上下文切换，这也是go被称之为现代化编程语言的原因。
使用Goroutine
Go中使用goroutine非常简单，只需要在调用函数的时候加上go关键字。一个goroutine必定对应一个函数，可以创建多个goroutine去执行相同的函数。
下面是一个示例：
go
func hello() {
fmt.Println("Hello Goroutine!")
}
func main() {
hello()
fmt.Println("main goroutine done!")
}这个例子中hello函数和主函数中的打印信息是串行的。
先将hello函数改成goroutine的：
go
func main() {
go hello() // 启动另外一个goroutine去执行hello函数
fmt.Println("main goroutine done!")
}再次执行会发现只打印main goroutine done!。这是因为main函数本身是在一个默认的goroutine中执行的，当main函数结束时，此goroutine运行结束，在main函数中启动的其他goroutine也会随之退出。
修改main函数：
go
unc main() {
go hello() // 启动另外一个goroutine去执行hello函数
fmt.Println("main goroutine done!")
time.Sleep(time.Second)
}此时再次执行就会再次打印两条信息了。
启动多个goroutine
在go中，可以同时启动多个goroutine：
go
package main
import (
"fmt"
"sync"
)
var wg sync.WaitGroup
func hello(i int) {
defer wg.Done() // goroutine结束就登记-1
fmt.Println("Hello Goroutine!", i)
}
func main() {
for i := 0; i < 10; i++ {
wg.Add(1) // 启动一个goroutine就登记+1
go hello(i)
}
wg.Wait() // 等待所有登记的goroutine都结束
}这里使用sync.WaitGroup来实现goroutine的同步。
执行代码，会发现10个协程并发打印信息，并且顺序是随机的（goroutine调度是随机的）。
Goroutine与线程
一个goroutine的栈内存在生命周期开始时只有2KB，但可以按需增大和缩小，最大可达到1GB。
GPM是go语言运行时（runtime）层面的实现，是go语言自己实现的一套调度系统，区别于操作系统调度线程。
事实上，GPM并不是官方术语，而是开发者用来概括go的并发模型的三大核心组件的：Goroutine、Processor、Machine。
Goroutine拥有自己的栈和上下文，其切换由运行时调度器管理，不依赖于操作系统的线程管理，因此比传统线程更轻量。
Processor表示逻辑处理器，管理着goroutine的队列，并负责调度goroutine到可用的machine上执行。P的数量决定了可以同时运行多个goroutine，可通过runtime.GOMAXPROCS设置（最大256），默认与CPU核数相等。
Machine表示内核线程（或系统线程），是在操作系统层面上执行任务的线程。Go运行时会将goroutine绑定到M上运行。换句话说，M负责实际执行P中的goroutine。当M在运行goroutine时，可以根据情况继续运行该goroutine，也可以将其切换出去以运行其他goroutine。
GMP示意图：
从线程调度讲，Go语言相比其他语言的优势在于goroutine是由go运行时自己调度的。这个调度器使用一个被称为m:n调度的技术，即将m个goroutine调度到n个OS线程上。其一大特点是goroutine的调度是在用户态下完成的，不涉及内核态与用户态之间频繁切换，包括内存的分配与释放，成本比调度OS线程低很多。
channel
很多场景下并发地协程之间是需要互相通信的，比如经典的并发同步问题：用两个协程交替打印奇数和偶数，这时候就要在两个协程之间互相通信，来保证打印的顺序。 Go通过channel实现协程间的通信。
共享内存也可以进行数据交换，但是共享内存容易出现并发安全问题，为了保证数据的准确性，需要使用互斥量对内存进行加锁，造成额外的性能消耗。
Channel 是有类型的管道，遵循先进先出的规则，保证数据的顺序。Channel 采用关键字chan 加上类型做声明，赋值取值采用符号<-。
Channel是引用类型，默认为nil。
go
var ch chan int
fmt.Println(ch) // 输出为<nil>声明的通道需要使用使用make函数初始化之后才能使用：
go
ch := make(chan int)channel操作
channel有发送，接收和关闭三种操作。如下所示：
func test(ch chan<- int) {
ch <- 10
close(ch)
}
func main() {
ch := make(chan int)
go test(ch)
fmt.Println(<-ch)
}
channel是有方向的，chan 是一个双向通道，既可以发送数据，也可以从中接收数据。chan<- 是一个单向通道，只能往其中发送数据。<-chan表示这是一个单向通道，只能往外取数据。
关闭通道并不是必须的，而是可以让系统自动垃圾回收。需要关闭通道的情况：明确知道没有更多的数据会被发送到通道时，可以关闭通道。关闭通道可以让接收方在读取所有数据后，通过检测到通道的关闭信号，安全地停止接收数据。
关闭后的通道有以下特点：
- 对一个关闭的通道发送数据会导致panic。
- 对一个关闭的通道接收数据会正常获取，如果通道里没有值了，会获取到对应类型的零值。
- 重复关闭通道会导致panic。
一般只有发送方才会主动关闭通道。
无缓冲channel和缓冲channel
无缓冲channel
无缓冲channel又称为阻塞channel，如下所示：
go
func main() {
ch := make(chan int)
ch <- 10
fmt.Println("send success")
}这段代码可以编译通过，但是执行会报错：all goroutines are asleep - deadlock!。原因是这是一个无缓冲channel，只有数据发送方，但是没有接收方，代码会在ch <- 10 阻塞住，形成死锁。
添加一个接收方解决死锁问题：
go
func recv(ch chan int) {
ret := <-ch
fmt.Println("recv success", ret)
}
func main() {
ch := make(chan int)
go recv(ch)
ch <- 10
fmt.Println("send success")
}无缓冲通道上的发送操作会阻塞，直到另一个goroutine在该通道上执行接收操作，这时才能发送成功，两个goroutine将继续执行。相反，如果接收操作先执行，接收方的goroutine将阻塞，直到另一个goroutine在该通道上发送一个值。这与阻塞队列的工作方式是类似的。
使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。因此，无缓冲通道也被称为同步通道。
有缓冲channel
下面创建一个有缓冲的channel：
go
func main() {
ch := make(chan int, 1)
ch <- 10
fmt.Println("send success")
}只要channel的容量大于零，则就是一个有缓冲的通道。
遍历通道
go
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go func() {
for i := 0; i < 100; i++ {
ch1 <- i
}
close(ch1)
}() // 匿名函数
go func() {
for {
i, ok := <-ch1 // if ok = false, it means the channel is closed
if !ok {
break
}
ch2 <- i * i
}
close(ch2)
}() // 匿名函数
for i := range ch2 { // the for struct will exits when channel is closed
fmt.Println(i)
}
}select
select是Go中的关键字，可以同时响应多个channel的操作。其使用类似于switch语句，有一系列case
分支和一个默认的分支。每个case会对应一个通道的通信过程。select会一直等待，直到某个case的通信操作完成时，就会执行case分支对应的语句。如下所示：
go
func test1(ch chan string) {
time.Sleep(time.Second * 5)
ch <- "test1"
}
func test2(ch chan string) {
time.Sleep(time.Second * 2)
ch <- "test2"
}
func main() {
output1 := make(chan string)
output2 := make(chan string)
go test1(output1)
go test2(output2)
select {
case s1 := <-output1:
fmt.Println("s1=", s1)
case s2 := <-output2:
fmt.Println("s2=", s2)
}
}在这个例子中，只要任何一个通道的通信完成，就会执行对应的case分支。如果多个channel同时ready，会随机选择一个执行。