内容介绍
- 协程的概念
- goroutine 的诞生
- 使用 goroutine 加快速度
- goroutine 的机制原理
前言：
协程（coroutine）是 Go 语言最大的特色之一，goroutine 的实现其实是通过协程。
协程的概念
协程一词最早出现在 1963 年发表的论文中，该论文的作者为美国计算机科学家 Melvin E.Conway。著名的康威定律：“设计系统的架构受制于产生这些设计的组织的沟通结构。” 也是这个作者。
协程是一种用户态的轻量级线程，可以想成一个线程里面可以有多个协程，而协程的调度完全由用户控制，协程也会有自己的 registers、context、stack 等等，并且由协程的调度器来控制说目前由哪个协程执行，哪个协程要被 block 住。
而相对于 Thread 及 Process 的调度，则是由 CPU 内核去进行调度，因此操作系统其实会有所谓许多的调度算法，并且可以进行抢占式调度，可以主动抢夺执行的控制权。
反之，协程是不行的，只能进行非抢占式的调度。 可以理解成，如果 coroutine 被 block 住，则会在用户态直接切换另外一个 coroutine 给此 thread 继续执行，这样其他 coroutine 就不会被 block 住，让资源能够有效的被利用，借此实现 Concurrent 的概念。
协程与线程
线程 是 CPU 调度的基本单位，多个线程可以通过共享进程的资源，通过共享内存等方式来进行线程间通信。
协程 可理解为轻量级线程，与线程相比，协程不受操作系统系统调度，协程调度由用户应用程序提供，协程调度器按照调度策略把协程调度到线程中运行。
- 协程只需花几 KB 就可以被创立，线程则需要几 MB 的内存才能创立
- 切换开销方面，协程远远低于线程，切换的速度也因此大幅提升
goroutine 的诞生
Golang 语言的 goroutine 其实就是协程，特别的是在语言层面直接原生支持创立协程，并在 runtime、系统调用等多方面对 goroutine 调度进行封装及处理。
相对于 Java 的建立线程，操作系统是会直接建立一个线程与其对应，而多个线程的间互相切换需要通过内核线程来进行，会有较大的上下文切换开销，造成的资源耗费，而 goroutine 是在代码上直接实现切换，不需要经过内核线程。
goroutine 的优势：
- 与线程相比, goroutine 非常便宜，可以根据应用程序的需求自动分配， 但在线程的大小通常是固定的
- 使用 goroutine 访问共享内存的时候 透过 channel 可以避免竞态条件的发生
比如，我们计算一个数字的质数，可以写出如下的代码:
package main
import (
"fmt"
"time"
)
func main() {
num := 300000
start := time.Now()
for i := 1; i <= num; i++ {
if isPrime(i) {
fmt.Println(i)
}
}
end := time.Now()
fmt.Println(end.Unix()-start.Unix(), "seconds")
}
func isPrime(num int) bool {
if num == 1 {
return false
} else if num == 2 {
return true
} else {
for i := 2; i < num; i++ {
if num%i == 0 {
return false
}
}
return true
}
}
上面的代码用 num ：= 300000 来测试，也就是从 1~300000 之间来看那些数字会是质数，如果是质数的话就把质数输出，最后看到最终花费了 37 秒。运行结果如下：
使用 goroutine 加快速度
package main
import (
"fmt"
"time"
)
func main() {
num := 300000
start := time.Now()
for i := 1; i <= num; i++ {
go findPrimes(i)
}
end := time.Now()
time.Sleep(5 * time.Second)
fmt.Println(end.Unix()-start.Unix(), "seconds")
}
func findPrimes(num int) {
if num == 1 {
return
} else if num == 2 {
fmt.Println(num)
} else {
for i := 2; i < num; i++ {
if num%i == 0 {
return
}
}
fmt.Println(num)
}
}
go findPrimestime. Sleep这边运行之后会发现输出的质数出现并不是从小到大的，这是因为这些 goroutine 是一起做事情的，所以谁先做完谁就先输出这样。
运行结果如下，最后花费了大概 11 秒：
goroutine 的机制原理
理解 goroutine 机制的原理，关键是理解 Go 语言是如何实现调度器模型的。
计算机科学领域的任何问题都可以通过添加间接中间层来解决。GPM 模型就是这一理论的实践者。
runtime.hproc.c- Sched 结构就是调度器，它维护有存储 M 和 G 的队列以及调度器的一些状态信息等
- M 结构是 Machine，系统线程，它由操作系统管理和调度的，goroutine 就是跑在 M 之上的; M 是一个很大的结构，里面维护小对象内存 cache（mcache）、当前执行的 goroutine、随机数发生器等等非常多的信息。
- P 结构是 Processor，处理器，它的主要用途就是用来执行 goroutine 的，它维护了一个 goroutine 队列，即 runqueue。 Processor 是让我们从 N:1 调度到 M:N 调度的重要部分。
- G 是 goroutine 实现的核心结构，它包含了栈，指令指针，以及其他对调度 goroutine 很重要的信息，例如其阻塞的 channel。
我们分别用三角形，矩形和圆形表示 Machine Processor 和 Goroutine：
在单核处理器的场景下，所有 goroutine 运行在同一个 M 系统线程中，每一个 M 系统线程维护一个 Processor，任何时刻，一个 Processor 中只有一个 goroutine，其他 goroutine 在 runqueue 中等待。
一个 goroutine 运行完自己的时间片后，让出上下文，回到 runqueue 中。 多核处理器的场景下，为了运行 goroutines，每个 M 系统线程会持有一个 Processor 。
可以看到 Go 的并发用起来非常简单，用了一个语法糖将内部复杂的实现结结实实的包装了起来。
其内部可以用下面这张图来概述：
在单核处理器的场景下，所有 goroutine 运行在同一个 M 系统线程中，每一个 M 系统线程维护一个 Processor，任何时刻，一个 Processor 中只有一个 goroutine，其他 goroutine 在 runqueue 中等待。一个 goroutine 运行完自己的时间片后，让出上下文，回到 runqueue 中。 多核处理器的场景下，为了运行 goroutines，每个 M 系统线程会持有一个 Processor 。
在正常情况下，scheduler 会按照上面的流程进行调度，但是线程会发生阻塞等情况，看一下goroutine对线程阻塞等的处理。