一、并发与并行
并发：同一时间段内执行多个任务
并行：同一时刻执行多个任务
Go语言的并发通过
goroutine
实现。
goroutine
类似于线程，属于用户态的线程，我们可以根据需要创建成千上万个
goroutine
并发工作。
goroutine
是由Go语言的运行时（runtime）调度完成，而线程是由操作系统调度完成。
Go语言还提供
channel
在多个
goroutine
间进行通信。
goroutine
和
channel
是 Go 语言秉承的 CSP（Communicating Sequential Process）并发模式的重要实现基础。
二、goroutine
Go语言中的
goroutine
就是这样一种机制，
goroutine
的概念类似于线程，但
goroutine
是由Go的运行时（runtime）调度和管理的。Go程序会智能地将 goroutine 中的任务合理地分配给每个CPU。Go语言之所以被称为现代化的编程语言，就是因为它在语言层面已经内置了调度和上下文切换的机制。
在Go语言编程中你不需要去自己写进程、线程、协程，你的技能包里只有一个技能–
goroutine
，当你需要让某个任务并发执行的时候，你只需要把这个任务包装成一个函数，开启一个
goroutine
去执行这个函数就可以了，就是这么简单粗暴。
使用goroutine
Go语言中使用
goroutine
非常简单，只需要在调用函数的时候在前面加上
go
关键字，就可以为一个函数创建一个
goroutine
。
一个
goroutine
必定对应一个函数，可以创建多个
goroutine
去执行相同的函数。
启动单个goroutine
启动goroutine的方式非常简单，只需要在调用的函数（普通函数和匿名函数）前面加上一个
go
关键字。
举个例子如下：
func hello() {
fmt.Println("Hello Goroutine!")
}
func main() {
hello()
fmt.Println("main goroutine done!")
}
这个示例中hello函数和下面的语句是串行的，执行的结果是打印完
Hello Goroutine!
后打印
main goroutine done!
。
接下来我们在调用hello函数前面加上关键字
go
，也就是启动一个goroutine去执行hello这个函数。
func main() {
go hello() // 启动另外一个goroutine去执行hello函数
fmt.Println("main goroutine done!")
}
这一次的执行结果只打印了
main goroutine done!
，并没有打印
Hello Goroutine!
。为什么呢？
在程序启动时，Go程序就会为
main()
函数创建一个默认的
goroutine
。
当main()函数返回的时候该
goroutine
就结束了，所有在
main()
函数中启动的
goroutine
会一同结束，
main
函数所在的
goroutine
就像是权利的游戏中的夜王，其他的
goroutine
都是异鬼，夜王一死它转化的那些异鬼也就全部GG了。
所以我们要想办法让main函数等一等hello函数，最简单粗暴的方式就是
time.Sleep
了。
func main() {
go hello() // 启动另外一个goroutine去执行hello函数
fmt.Println("main goroutine done!")
time.Sleep(time.Second)
}
执行上面的代码你会发现，这一次先打印
main goroutine done!
，然后紧接着打印
Hello Goroutine!
。
首先为什么会先打印
main goroutine done!
是因为我们在创建新的goroutine的时候需要花费一些时间，而此时main函数所在的
goroutine
是继续执行的。
启动多个goroutine
在Go语言中实现并发就是这样简单，我们还可以启动多个
goroutine
。让我们再来一个例子： （这里使用了
sync.WaitGroup
来实现goroutine的同步）
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都结束
}
多次执行上面的代码，会发现每次打印的数字的顺序都不一致。这是因为10个
goroutine
是并发执行的，而
goroutine
的调度是随机的。
goroutine与线程
可增长的栈
OS线程（操作系统线程）一般都有固定的栈内存（通常为2MB）,一个
goroutine
的栈在其生命周期开始时只有很小的栈（典型情况下2KB），
goroutine
的栈不是固定的，他可以按需增大和缩小，
goroutine
的栈大小限制可以达到1GB，虽然极少会用到这么大。所以在Go语言中一次创建十万左右的
goroutine
也是可以的。
goroutine调度
GPM
是Go语言运行时（runtime）层面的实现，是go语言自己实现的一套调度系统。区别于操作系统调度OS线程。
-
G
-
P
-
M（machine）
P与M一般也是一一对应的。他们关系是： P管理着一组G挂载在M上运行。当一个G长久阻塞在一个M上时，runtime会新建一个M，阻塞G所在的P会把其他的G 挂载在新建的M上。当旧的G阻塞完成或者认为其已经死掉时 回收旧的M。
P的个数是通过
runtime.GOMAXPROCS
设定（最大256），Go1.5版本之后默认为物理线程数。 在并发量大的时候会增加一些P和M，但不会太多，切换太频繁的话得不偿失。
单从线程调度讲，Go语言相比起其他语言的优势在于OS线程是由OS内核来调度的，
goroutine
则是由Go运行时（runtime）自己的调度器调度的，这个调度器使用一个称为m:n调度的技术（复用/调度m个goroutine到n个OS线程）。 其一大特点是goroutine的调度是在用户态下完成的， 不涉及内核态与用户态之间的频繁切换，包括内存的分配与释放，都是在用户态维护着一块大的内存池， 不直接调用系统的malloc函数（除非内存池需要改变），成本比调度OS线程低很多。 另一方面充分利用了多核的硬件资源，近似的把若干goroutine均分在物理线程上， 再加上本身goroutine的超轻量，以上种种保证了go调度方面的性能。
了解更多
GOMAXPROCS
Go运行时的调度器使用
GOMAXPROCS
参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。例如在一个8核心的机器上，调度器会把Go代码同时调度到8个OS线程上（GOMAXPROCS是m:n调度中的n）。
Go语言中可以通过
runtime.GOMAXPROCS()
函数设置当前程序并发时占用的CPU逻辑核心数。
Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。
我们可以通过将任务分配到不同的CPU逻辑核心上实现并行的效果，这里举个例子：
func a() {
for i := 1; i < 10; i++ {
fmt.Println("A:", i)
}
}
func b() {
for i := 1; i < 10; i++ {
fmt.Println("B:", i)
}
}
func main() {
runtime.GOMAXPROCS(1)
go a()
go b()
time.Sleep(time.Second)
}
两个任务只有一个逻辑核心，此时是做完一个任务再做另一个任务。 将逻辑核心数设为2，此时两个任务并行执行，代码如下。
func a() {
for i := 1; i < 10; i++ {
fmt.Println("A:", i)
}
}
func b() {
for i := 1; i < 10; i++ {
fmt.Println("B:", i)
}
}
func main() {
runtime.GOMAXPROCS(2)
go a()
go b()
time.Sleep(time.Second)
}
Go语言中的操作系统线程和goroutine的关系：
- 一个操作系统线程对应用户态多个goroutine。
- go程序可以同时使用多个操作系统线程。
- goroutine和OS线程是多对多的关系，即m:n。
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)