1、并发相关回顾

1.1 进程、线程、协程

进程：进程是系统进行资源分配的基本单位，有独立的内存空间。

线程：线程是进程的一个执行实体，线程是 CPU 调度和分派的基本单位，线程依附于进程存在，每个线程会共享父进程的资源。

协程：**协程是一种用户态的轻量级线程，**协程的调度完全由用户控制，协程间切换只需要保存任务的上下文，没有内核的开销。

协程与线程主要区别是它将不再被内核调度，而是交给了程序自己而线程是将自己交给内核调度，所以也不难理解golang中调度器的存在。

1.2 并发与并行的区别

  • 并发：单核CPU，线程通过时间片或者让出控制权来实现任务切换，达到 “同时” 运行多个任务的目的。本质上任意时刻都只有一个任务被执行，其他任务则处于等待状态。
  • 并行：多核CPU，可以让同一进程中的"多线程"做到真正意义的同时运行。
  • 一个进程可以创建和撤销多个线程;同一个进程中的多个线程之间可以并发执行。

1.3 Go协程：Goroutine

在golang中，goroutine是Golang独有的协程，区别于协程（coroutines）其他语言py、java等中的协程概念，也没有其他语言的进程池、线程池等。

Go协程 区别 与 协程 的区别：

  • Go 协程意味着并行（或者可以以并行的方式部署），协程一般来说不是这样的
  • Go 协程通过通道来通信；协程通过让出和恢复操作来通信

Go 协程比协程更强大，也很容易从协程的逻辑复用到 Go 协程。

1.4 Goroutine 优势

  • 上下文切换代价小： Goroutine 上下文切换只涉及到三个寄存器（PC / SP / DX）的值修改；而对比线程的上下文切换则需要涉及模式切换（从用户态切换到内核态）、以及 16 个寄存器、PC、SP…等寄存器的刷新；

  • **内存占用少：**线程栈空间通常是 2M，Goroutine 栈空间最小 2K；

  • Golang 程序中可以轻松支持10w 级别的 Goroutine 运行，而线程数量达到 1k 时，内存占用就已经达到 2G。

  • Go 程序通过调度器来调度**Goroutine 在内核线程上执行，**但是 Goroutine 并不直接绑定 OS 线程 M - Machine运行，而是由 Goroutine Scheduler 中的 P - Processor （逻辑处理器）来作获取内核线程资源的『中介』。

1.5 Go高并发的根本原因

4~5KB

Goroutine是Go语言特有的并发体，是一种轻量级的线程，由go关键字启动。在真实的Go语言的实现中，goroutine和系统线程也不是等价的。尽管两者的区别实际上只是一个量的区别，但正是这个量变引发了Go语言并发编程质的飞跃。

每个系统级线程都会有一个固定大小的栈（一般默认可能是2MB），这个栈主要用来保存函数递归调用时参数和局部变量。固定了栈的大小导致了两个问题：一是对于很多只需要很小的栈空间的线程来说是一个巨大的浪费，二是对于少数需要巨大栈空间的线程来说又面临栈溢出的风险。针对这两个问题的解决方案是：要么降低固定的栈大小，提升空间的利用率；要么增大栈的大小以允许更深的函数递归调用，但这两者是没法同时兼得的。相反，一个Goroutine会以一个很小的栈启动（可能是2KB或4KB），当遇到深度递归导致当前栈空间不足时，Goroutine会根据需要动态地伸缩栈的大小（主流实现中栈的最大值可达到1GB）。因为启动的代价很小，所以我们可以轻易地启动成千上万个Goroutine。

runtime.GOMAXPROCS

在Go语言中启动一个Goroutine不仅和调用函数一样简单，而且Goroutine之间调度代价也很低，这些因素极大地促进了并发编程的流行和发展。

goroutine 奉行通过通信来共享内存，而不是共享内存来通信

2、Goroutine

2.1 Goroutine 定义

在java/c++中我们要实现并发编程的时候，我们通常需要自己维护一个线程池，并且需要自己去包装一个又一个的任务，同时需要自己去调度线程执行任务并维护上下文切换。

Go语言中的goroutine的概念类似于线程，但是， goroutine是由Go的运行时（runtime）调度和管理的。Go程序会智能地将 goroutine 中的任务合理地分配给每个CPU。Go语言之所以被称为现代化的编程语言，就是因为它在语言层面已经内置了调度和上下文切换的机制。

Go语言中不需要去自己写进程、线程、协程，当需要让某个任务并发执行的时候，只需要把这个任务包装成一个函数，开启一个goroutine去执行这个函数即可。

2.2 Goroutine 用法

  • 在调用函数的时候在前面加上go关键字，就可以为一个函数创建一个goroutine。

  • 一个goroutine必定对应一个函数，可以创建多个goroutine去执行相同的函数。

2.2.1 启动单个goroutine

启动goroutine的方式非常简单，只需要在调用的函数（普通函数和匿名函数）前面加上一个go关键字。

package main

import "fmt"

func main() {
	fmt.Println("main")
	go hi() // 启动 goroutine
}
func hi() {
	fmt.Println("hi")
}

输出：

main

这一次的执行结果只打印了main，并没有打印 hi 。why？

  • 在程序启动时，Go程序就会为main()函数创建一个默认的goroutine。

  • 当main()函数返回的时候该goroutine就结束了，所有在main()函数中启动的goroutine会一同结束.

何解？

让main goroutine 慢一些，等等 hi goroutine

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("main")
	go hi() // 启动 goroutine
	time.Sleep(time.Second)   // main goroutine 睡一会
}
func hi() {
	fmt.Println("hi")
}

main
hi

time.Sleep (time.Second) 表示等待一秒，这里是让 main goroutine 等一秒

优化：通过WaitGroup来计数等待 goroutine

WaitGroup的用途：它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。

WaitGroup总共有三个方法：Add(delta int),Done(),Wait()。

  • Add:添加或者减少等待goroutine的数量

  • Done:相当于Add(-1)

  • Wait:执行阻塞，直到所有的WaitGroup数量变成0

var wg sync.WaitGroup

func hi() {
	defer wg.Done() // goroutine结束就登记-1
	fmt.Println("hi Goroutine!", i)
}
func main() {
	wg.Add(1)  //  计数牌 + 1
	go hi()   //   启动 hi goroutine
	wg.Wait()  // 等待所有登记的goroutine都结束
}

2.2.2 启动多个goroutine

也使用了sync.WaitGroup来实现goroutine的同步，启动多个goroutine

var wg sync.WaitGroup   // 定义全局变量 wg

func hello(i int) {
    defer wg.Done() // 子goroutine结束就登记-1，即：计数牌-1
    fmt.Println("Hello Goroutine!", i)
}
func main() {

    for i := 0; i < 10; i++ {
        wg.Add(1) // 启动一个goroutine就登记+1，即：计数牌+1
        go hello(i)
    }
    wg.Wait() // 等待所有登记的goroutine都结束，再退出
}

多次执行上面的代码，会发现每次打印的数字的顺序都不一致。这是因为10个goroutine是并发执行的，而goroutine的调度是随机的。

2.3 启动匿名函数 goroutine

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func main() {
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func(i int) {
			fmt.Println("匿名函数goroutine，解决闭包参数i：", i)
			wg.Done() 
		}(i)
	}
	wg.Wait()
}

3、runtime包

Go语言中可以通过runtime.GOMAXPROCS()函数指定当前程序并发时占用的CPU逻辑核心数。Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func a() {
	for i := 1; i < 10; i++ {
		fmt.Println("A:", i)
	}
	wg.Done()
}

func b() {
	for i := 1; i < 10; i++ {
		fmt.Println("B:", i)
	}
	wg.Done()
}

var wg sync.WaitGroup

func main() {
	runtime.GOMAXPROCS(1)   // 只占用1核心CPU
	wg.Add(2)
	go a()
	go b()
	wg.Wait()
}

两个任务只有一个逻辑核心，此时是做完一个任务再做另一个任务。 将逻辑核心数设为2，此时两个任务并行执行，代码如下。

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func a() {
	for i := 1; i < 10; i++ {
		fmt.Println("A:", i)
	}
	wg.Done()
}

func b() {
	for i := 1; i < 100; i++ {
		fmt.Println("B:", i)
	}
	wg.Done()
}

var wg sync.WaitGroup

func main() {
	runtime.GOMAXPROCS(2) // 占用2核心CPU
	wg.Add(2)
	go a()
	go b()
	wg.Wait()
}

Go语言中的操作系统线程和goroutine的关系：

  • 1.一个操作系统线程对应用户态多个goroutine。
  • 2.go程序可以同时使用多个操作系统线程。
  • 3.goroutine和OS线程是多对多的关系，即m:n。

4、goroutine 调度

GPM是Go语言运行时（runtime）层面的实现，是go语言自己实现的一套调度系统。区别于操作系统调度OS线程。

1.G很好理解，就是个goroutine的，里面除了存放本goroutine信息外 还有与所在P的绑定等信息。
2.P管理着一组goroutine队列，P里面会存储当前goroutine运行的上下文环境（函数指针，堆栈地址及地址边界），P会对自己管理的goroutine队列做一些调度（比如把占用CPU时间较长的goroutine暂停、运行后续的goroutine等等）当自己的队列消费完了就去全局队列里取，如果全局队列里也消费完了会去其他P的队列里抢任务。
3.M（machine）是Go运行时（runtime）对操作系统内核线程的虚拟， M与内核线程一般是一一映射的关系， 一个groutine最终是要放到M上执行的；
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调度方面的性能。