golang 源码分析01 GoRoutine 上

https://blog.csdn.net/robertkun?t=1&type=blog

一、Golang简介

1.1概述

Golang语言是Google公司开发的新一代编程语言，简称Go语言，Go 是有表达力、简洁、清晰和有效率的。它的并行机制使其很容易编写多核和网络应用，而新奇的类型系统允许构建有弹性的模块化程序。 Go 编译到机器码非常快速，同时具有便利的垃圾回收和强大的运行时反射。而他最广为人知的特性便是语言层面上对多核编程的支持，他有简单的关键字go来实现并行，就像下面这样：

Go的并行单元并不是传统意义上的线程，线程切换需要很大的上下文，这种切换消耗了大量CPU时间，而Go采用更轻量的协程（goroutine）来处理，大大提高了并行度，被称为“最并行的语言”。最近引起容器技术浪潮的Docker就是Go写的。由于GC穿插在goroutine之中，但是本篇文章并不讨论GC相关内容，故略过GC，主要讨论goroutine的调度问题。本文针对的go版本是截止2016年6月29日最新的Go1.7。

 

1.2与其他并发模型的对比

Python等解释性语言采用的是多进程并发模型，进程的上下文是最大的，所以切换耗费巨大，同时由于多进程通信只能用socket通讯，或者专门设置共享内存，给编程带来了极大的困扰与不便；

C++，Java 等语言通常会采用多线程并发模型，相比进程，线程的上下文要小很多，而且多个线程之间本来就是共享内存的，所以编程相比要轻松很多。但是线程的启动和销毁，切换依然要耗费大量CPU时间；

于是出现了线程池技术，将线程先储存起来，保持一定的数量，来避免频繁开启/关闭线程的时间消耗，但是这种初级的技术存在一些问题，比如有线程一直被IO阻塞，这样的话这个线程一直占据着坑位，导致后面的任务排不到队，拿不到线程来执行；

而Go的并发较为复杂，Go采用了更轻量的数据结构来代替线程，这种数据结构相比线程更轻量，他有自己的栈，切换起来更快。然而真正执行并发的还是线程，Go通过调度器将goroutine调度到线程中执行，并适时地释放和创建新的线程，并且当一个正在运行的goroutine进入阻塞（常见场景就是等待IO）时，将其脱离占用的线程，将其他准备好运行的goroutine放在该线程上执行。通过较为复杂的调度手段，使得整个系统获得极高的并行度同时又不耗费大量的CPU资源。

1.3 Goroutine的特点

Goroutine的引入是为了方便高并发程序的编写。一个Goroutine在进行阻塞操作（比如系统调用）时，会把当前线程中的其他Goroutine移交到其他线程中继续执行，从而避免了整个程序的阻塞。

由于Golang引入了垃圾回收（gc），在执行gc时就要求Goroutine是停止的。通过自己实现调度器，就可以方便的实现该功能。 通过多个Goroutine来实现并发程序，既有异步IO的优势，又具有多线程、多进程编写程序的便利性。

引入Goroutine，也意味着引入了极大的复杂性。一个Goroutine既要包含要执行的代码，又要包含用于执行该代码的栈和PC、SP指针。

既然每个Goroutine都有自己的栈，那么在创建Goroutine时，就要同时创建对应的栈。Goroutine在执行时，栈空间会不停增长。栈通常是连续增长的，由于每个进程中的各个线程共享虚拟内存空间，当有多个线程时，就需要为每个线程分配不同起始地址的栈。这就需要在分配栈之前先预估每个线程栈的大小。如果线程数量非常多，就很容易栈溢出。

为了解决这个问题，就有了Split Stacks 技术：创建栈时，只分配一块比较小的内存，如果进行某次函数调用导致栈空间不足时，就会在其他地方分配一块新的栈空间。新的空间不需要和老的栈空间连续。函数调用的参数会拷贝到新的栈空间中，接下来的函数执行都在新栈空间中进行。

Golang的栈管理方式与此类似，但是为了更高的效率，使用了连续栈（ Golang连续栈） 实现方式也是先分配一块固定大小的栈，在栈空间不足时，分配一块更大的栈，并把旧的栈全部拷贝到新栈中。这样避免了Split Stacks方法可能导致的频繁内存分配和释放。

Goroutine的执行是可以被抢占的。如果一个Goroutine一直占用CPU，长时间没有被调度过，就会被runtime抢占掉，把CPU时间交给其他Goroutine。

2.3具体函数

goroutine调度器的代码在/src/runtime/proc.go中，一些比较关键的函数分析如下。

1.schedule函数
schedule函数在runtime需要进行调度时执行，为当前的P寻找一个可以运行的G并执行它，寻找顺序如下：
1） 调用runqget函数来从P自己的runnable G队列中得到一个可以执行的G；
2） 如果1）失败，则调用findrunnable函数去寻找一个可以执行的G；
3） 如果2）也没有得到可以执行的G，那么结束调度，从上次的现场继续执行。

 

2.findrunnable函数
findrunnable函数负责给一个P寻找可以执行的G，它的寻找顺序如下：
1） 调用runqget函数来从P自己的runnable G队列中得到一个可以执行的G；
2） 如果1）失败，调用globrunqget函数从全局runnableG队列中得到一个可以执行的G；
3） 如果2）失败，调用netpoll（非阻塞）函数取一个异步回调的G；
4） 如果3）失败，尝试从其他P那里偷取一半数量的G过来；
5） 如果4）失败，再次调用globrunqget函数从全局runnableG队列中得到一个可以执行的G；
6） 如果5）失败，调用netpoll（阻塞）函数取一个异步回调的G；
7） 如果6）仍然没有取到G，那么调用stopm函数停止这个M。

 

3.newproc函数
newproc函数负责创建一个可以运行的G并将其放在当前的P的runnable G队列中，它是类似”go func() { … }”语句真正被编译器翻译后的调用，核心代码在newproc1函数。

这个函数执行顺序如下：
1） 获得当前的G所在的 P，然后从free G队列中取出一个G；
2） 如果1）取到则对这个G进行参数配置，否则新建一个G；
3） 将G加入P的runnable G队列。

4.goexit0函数
goexit函数是当G退出时调用的。这个函数对G进行一些设置后，将它放入free G列表中，供以后复用，之后调用schedule函数调度。

5.handoffp函数
handoffp函数将P从系统调用或阻塞的M中传递出去，如果P还有runnable G队列，那么新开一个M，调用startm函数，新开的M不空旋。

6.startm函数
startm函数调度一个M或者必要时创建一个M来运行指定的P。

7.entersyscall_handoff函数
entersyscall_handoff函数用来在goroutine进入系统调用（可能会阻塞）时将P传递出去

8.sysmon函数
sysmon函数是Go runtime启动时创建的，负责监控所有goroutine的状态，判断是否需要GC，进行netpoll等操作。sysmon函数中会调用retake函数进行抢占式调度

9.retake函数
retake函数是实现抢占式调度的关键，它的实现步骤如下：
1） 遍历所有P，如果该P处于系统调用中且阻塞，则调用handoffp将其移交其他M；
2） 如果该P处于运行状态，且上次调度的时间超过了一定的阈值，那么就调用preemptone函数这将导致该 P 中正在执行的 G 进行下一次函数调用时，导致栈空间检查失败。进而触发morestack()（汇编代码，位于asm_XXX.s中）然后进行一连串的函数调用，
主要的调用过程如下：morestack()（汇编代码）-> newstack() -> gopreempt_m() -> goschedImpl() ->schedule()在goschedImpl()函数中，会通过调用dropg()将 G 与 M 解除绑定；
再调用globrunqput()将 G 加入全局runnable队列中。最后调用schedule() 来为当前 P 设置新的可执行的 G 

三、小结

Go语言由于存在自己的runtime，使得goroutine的实现相对简单，笔者曾尝试在C++11中实现类似功能，但是保护现场的抢占式调度和G被阻塞后传递给其他Thread的调用很难实现，毕竟Go的所有调用都经过了runtime，这么想来，C#、VB之类的语言实现起来应该容易一点。笔者在C++11中实现的goroutine不支持抢占式调度和阻塞后传递的功能，所以仅仅和直接使用std::thread进行多线程操作进行了对比，工作函数为计算密集的操作，下面是效果对比图

 

go源码proc.go

先看main函数入口

1.调用getg()方法获取当前g的指针

2.g0的raceCtx只能用于主协程的parent，不能用于别的

3.对于64位的操作系统，最大栈空间是1GB，对于32位的操作系统，最大栈空间是250MB

4.lockOSThread 锁住系统线程，校验主函数必须在m0线程上

5.执行doInit()方法初始化，执行runtime的inittask任务，必须在defer函数之前完成

6.defer函数，把刚才锁住的OSThread，进行解锁unlock

7.gcenable()， 就是启动后台的gc线程

8.校验cgo的一些属性不能为空

9.启动模板线程 template thread

10.执行main_iniitask的初始化

11.解锁系统线程OSThread

12.判断如果是压缩的，或者是一个lib包，就直接return

13.让其他的协程先结束打印异常trace，完成后，再退出

调用exit退出main函数

 

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

init 方法，启动强制gc的协程

也是需要先加锁lock，然后启动gc

核心方法 ： startm

startm 方法 ：

   1.调度一些M内核线程，来运行P；如果没有M内核线程，就创建

   2.如果p为nil，就尝试获取一个空闲的idle P；如果没有空闲的P，就什么也不做

   3.在m.p 为nil 的情况下运行，这样不会允许写屏障

   4.调度的lock，先unlock解锁

   5.如果设置了自旋spinning，那么就-1，发现如果减到了负数，就抛出异常

   6.如果没有m，也就是没有工作的内核线程，那么就释放sched锁，然后调用newm方法，来新建内核线程

   7.一个运行的G，但是此时没有运行的M，因为新建的M还没有启动，所以此时就会抛出一个死锁deadlock

   8.为了避免死锁这个case，就给这个新建的内核线程M预分配ID，所以就把这个新建的内核线程M标记为running，并且

      这个内核线程M最终调度执行任何排队的G协程