目前，WebServer几种主流的并发模型：
- 多线程，每个线程一次处理一个请求，在当前请求处理完成之前不会接收其它请求；但在高并发环境下，多线程的开销比较大；
- 基于回调的异步IO，如Nginx服务器使用的epoll模型，这种模式通过事件驱动的方式使用异步IO，使服务器持续运转，但人的思维模式是串行的，大量回调函数会把流程分割，对于问题本身的反应不够自然；
- 协程，不需要抢占式调度，可以有效提高线程的任务并发性，而避免多线程的缺点；但原生支持协程的语言还很少。
协程（coroutine）是Go语言中的轻量级线程实现，由Go运行时（runtime）管理。
在一个函数调用前加上go关键字，这次调用就会在一个新的goroutine中并发执行。当被调用的函数返回时，这个goroutine也自动结束。需要注意的是，如果这个函数有返回值，那么这个返回值会被丢弃。
先看下面的例子：
func Add(x, y int) {
z := x + y
fmt.Println(z)
}
func main() {
for i:=0; i<10; i++ {
go Add(i, i)
}
}
执行上面的代码，会发现屏幕什么也没打印出来，程序就退出了。
对于上面的例子，main()函数启动了10个goroutine，然后返回，这时程序就退出了，而被启动的执行Add()的goroutine没来得及执行。我们想要让main()函数等待所有goroutine退出后再返回，但如何知道goroutine都退出了呢？这就引出了多个goroutine之间通信的问题。
在工程上，有两种最常见的并发通信模型：共享内存和消息。
来看下面的例子，10个goroutine共享了变量counter，每个goroutine执行完成后，将counter值加1。因为10个goroutine是并发执行的，所以我们还引入了锁，也就是代码中的lock变量。在main()函数中，使用for循环来不断检查counter值，当其值达到10时，说明所有goroutine都执行完毕了，这时main()返回，程序退出。
package main
import (
"fmt"
"sync"
"runtime"
)
var counter int = 0
func Count(lock *sync.Mutex) {
lock.Lock()
counter++
fmt.Println("counter =", counter)
lock.Unlock()
}
func main() {
lock := &sync.Mutex{}
for i:=0; i<10; i++ {
go Count(lock)
}
for {
lock.Lock()
c := counter
lock.Unlock()
runtime.Gosched() // 出让时间片
if c >= 10 {
break
}
}
}
上面的例子，使用了锁变量（属于一种共享内存）来同步协程，事实上Go语言主要使用消息机制（channel）来作为通信模型。
channel
消息机制认为每个并发单元是自包含的、独立的个体，并且都有自己的变量，但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种，那就是消息。
channel是Go语言在语言级别提供的goroutine间的通信方式，我们可以使用channel在多个goroutine之间传递消息。channel是进程内的通信方式，因此通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。
channel是类型相关的，一个channel只能传递一种类型的值，这个类型需要在声明channel时指定。
channel的声明形式为：
var chanName chan ElementType
举个例子，声明一个传递int类型的channel：
var ch chan int
使用内置函数make()定义一个channel：
ch := make(chan int)
在channel的用法中，最常见的包括写入和读出：
// 将一个数据value写入至channel，这会导致阻塞，直到有其他goroutine从这个channel中读取数据
ch <- value
// 从channel中读取数据，如果channel之前没有写入数据，也会导致阻塞，直到channel中被写入数据为止
value := <-ch
默认情况下，channel的接收和发送都是阻塞的，除非另一端已准备好。
我们还可以创建一个带缓冲的channel：
c := make(chan int, 1024)
// 从带缓冲的channel中读数据
for i:=range c {
...
}
此时，创建一个大小为1024的int类型的channel，即使没有读取方，写入方也可以一直往channel里写入，在缓冲区被填完之前都不会阻塞。
可以关闭不再使用的channel：
close(ch)
应该在生产者的地方关闭channel，如果在消费者的地方关闭，容易引起panic；
在一个已关闭 channel 上执行接收操作(<-ch)总是能够立即返回，返回值是对应类型的零值。
现在利用channel来重写上面的例子：
func Count(ch chan int) {
ch <- 1
fmt.Println("Counting")
}
func main() {
chs := make([] chan int, 10)//创建大小为10的类型为传递int类型的channel的数组
for i:=0; i<10; i++ {
chs[i] = make(chan int)//数组的成员是int类型channel
go Count(chs[i])//启动协程
}
for _, ch := range(chs) {
<-ch
}
}
在这个例子中，定义了一个包含10个channel的数组，并把数组中的每个channel分配给10个不同的goroutine。在每个goroutine启动完成后，向goroutine写入一个数据，在这个channel被读取前，写 这个操作是阻塞的（也即10个goroutine无论是否都启动完成，都在阻塞，等待读（下面的for循环））。在所有的goroutine启动完成后（即使没完成全部启动就开始读），依次从10个channel中读取数据，在对应的channel写入数据前，读这个操作也是阻塞的，即从chs[0]开始，如果没有向ch[0]变量内写入1，那么向外读就一直阻塞，直到向ch[0]变量内写入了1；继续循环chs[1]。这样，就用channel实现了类似锁的功能，并保证了所有goroutine完成后main()才返回。
另外，我们在将一个channel变量传递到一个函数时，可以通过将其指定为单向channel变量，从而限制该函数中可以对此channel的操作。
单向channel变量的声明：
var ch1 chan int // 普通channel
var ch2 chan <- int // 只用于写int数据
var ch3 <-chan int // 只用于读int数据
可以通过类型转换，将一个channel转换为单向的：
ch4 := make(chan int)
ch5 := <-chan int(ch4) // 单向读
ch6 := chan<- int(ch4) //单向写
单向channel的作用有点类似于c++中的const关键字，用于遵循代码“最小权限原则”。
例如在一个函数中使用单向读channel：
func Parse(ch <-chan int) {
for value := range ch {
fmt.Println("Parsing value", value)
}
}
channel作为一种原生类型，本身也可以通过channel进行传递，例如下面这个流式处理结构：
type PipeData struct {
value int
handler func(int) int
next chan int
}
func handle(queue chan *PipeData) {
for data := range queue {
data.next <- data.handler(data.value)
}
}
select
在UNIX中，select()函数用来监控一组描述符，该机制常被用于实现高并发的socket服务器程序。Go语言直接在语言级别支持select关键字，用于处理异步IO问题，大致结构如下：
select {
case <- chan1:
// 如果chan1成功读到数据
case chan2 <- 1:
// 如果成功向chan2写入数据
default:
// 默认分支
}
select默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的（所有的case下的channel都会监听；有两个channel的情况下，一个阻塞（没准备好），另一个有发送或者接收（准备好了），则执行后者；多个channel的情况下，没准备好的不考虑，从准备好的随机选择一个执行）。
Go语言没有对channel提供直接的超时处理机制，但我们可以利用select来间接实现，例如：
//实现并执行一个匿名的超时等待函数
timeout := make(chan bool, 1)
go func() {
time.Sleep(1e9)//等待1秒钟
timeout <- true
}()
//使用timeout这个channel
select{
case <- ch:
// 从ch中读取到数据
case <- timeout:
// 没有从ch中读取到数据，但从timeout中读取到了数据
}
这样使用select就可以避免永久等待的问题，因为程序会在timeout中获取到一个数据后继续执行，而无论对ch的读取是否还处于等待状态。
并发
早期版本的Go编译器并不能很智能的发现和利用多核的优势，即使在我们的代码中创建了多个goroutine，但实际上所有这些goroutine都允许在同一个CPU上，在一个goroutine得到时间片执行的时候其它goroutine都会处于等待状态。
实现下面的代码可以显式指定编译器将goroutine调度到多个CPU上运行。
import "runtime"
...
runtime.GOMAXPROCS(4)
PS：runtime包中有几个处理goroutine的函数，
| 函数 | 说明 |
|---|---|
| Goexit | 退出当前执行的goroutine，但是defer函数还会继续调用 |
| Gosched | 让出当前goroutine的执行权限，调度器安排其他等待的任务运行，并在下次某个时候从该位置恢复执行 |
| NumCPU | 返回 CPU 核数量 |
| NumGoroutine | 返回正在执行和排队的任务总数 |
| GOMAXPROCS | 用来设置可以并行计算的CPU核数的最大值，并返回之前的值 |
线程模型——高级语言对内核线程的封装实现
- N:1模型，N个用户空间线程在1个内核空间线程上运行。优势是上下文切换非常快但是无法利用多核系统的优点。
- 1:1模型，1个内核空间线程运行一个用户空间线程。这种充分利用了多核系统的优势但是上下文切换非常慢，因为每一次调度都会在用户态和内核态之间切换。（POSIX线程模型(pthread)，Java）
- M:N模型， 每个用户线程对应多个内核空间线程，同时也可以一个内核空间线程对应多个用户空间线程。Go打算采用这种模型，使用任意个内核模型管理任意个goroutine。这样结合了以上两种模型的优点，但缺点就是调度的复杂性。
GoLang调度
Go的调度器使用了三种结构：M，P，S
M：内核线程，类似于标准的POSIX线程，M代表machine。
G：go routine，并发的最小逻辑单元，由程序员创建；它拥有自己的栈，程序计数器（instruction counter）和一些关于goroutine调度的信息（如正在阻塞的channel）。
P：表示调度的上下文。可以把它看作是一个局部的调度器，让Go代码跑在一个单独的线程上。这是让Go从一个N:1调度器映射到一个M:N调度器的关键。每个P会维护一个本地的go routine队列；
如上图所示，每个线程运行了一个goroutine，所以必须得维持一个上下文P。
上下文的数量由启动时环境变量GOMAXPROCS或者是由runtime的方法GOMAXPROCS()决定（默认值为1）。这意味着在程序执行的任意时刻都只有GOMAXPROCS个goroutine在同时运行。
灰色的goroutine没有在运行，等待被调度。它们被维护在一个队列（runqueues）里。当一个go语句执行，就将一个新的goroutine添加到队列尾；当运行当前goroutine到调度点时，就从队列中弹出一个新的goroutine。
每一个context拥有一个局部的runqueue。之前版本的Go调度器只有一个全局的带有互斥锁的runqueue，这样线程经常被阻塞等待其它线程解锁，在多核机器上性能表现及其差。
之所以要维护多个context，是因为当一个OS线程被阻塞时，我们可以把contex移到其它的线程中去。
如上图所示，当一个内核线程M0要被阻塞时，P将会去M1上继续运行由M1接管其任务队列。Go的调度器保证了拥有足够的线程跑所有的contexts。因为还有在执行的goroutine，M0会暂时挂起。当syscall返回时，M0会尝试获取一个context来运行G0。一般情况下，它会从其它内核线程偷一个过来。如果没有偷到，它会把G0放到一个全局的runqueue内，将自己放回线程池，进入睡眠状态。
当contexts运行完所有的本地runqueue时，它会从全局runqueue拉取goroutine。contexts也会周期性检查全局runqueue是否存在goroutine，以防止全局runqueue中的goroutine饿死。
这就是为什么Go程序多线程运行的原因，即使GOMAXPROCS只有1。
另外一种情况就是某个context的goroutine运行完了，全局runqueue也没有了goroutine，而其它context还有大量goroutine需要运行。这时候就需要从其它的地方获取goroutine。如图所示，context会尝试从其它context的runqueue里面偷一半的goroutine。这样就能确保所有的线程都能以最大负荷运行。
原文：
1、《Go语言编程》
2、http://morsmachine.dk/go-scheduler
3、 https://www.cnblogs.com/chenny7/p/4498322.html
4、https://studygolang.com/articles/9610