1. Go语言的发展现状

如果从2007年9月20日那个下午三个“程序员大佬”在谷歌总部的一间办公室里进行的一次有关设计一门新编程语言的讨论算起，那么Go语言已经度过了自己的13个年头了。

如果从2009年11月10日Go语言正式开源发布算起，Go语言也即将迎来自己的第11个生日。

2020年，Go联合创始人Rob Pike在专访中也认可了Go确实已成为云基础架构的语言。在Go即将迎来自己的11个生日的时候，Hacker News有人发起了“Go已超过10岁了，你觉得这门语言如何？”的提问，收到了广泛的关注和回答。国内媒体将这些问答整理后得到的结论是：“人生苦短，我要换Go”。

Stackoverflow官博11月2日发表的《Go语言有哪些优点？探讨导致Go语言日益流行的特征 》一文对Go语言的发展趋势描述的贴切：Go语言就像爬行的藤蔓，虽缓慢，但却逐渐占据了开发世界。它正以一种郁郁葱葱的并且在许多方面都很优越的编程能力覆盖着在它之前出现的所有事物。

不管你是否承认，Go在IT就业市场已经成为事实上的“香饽饽”之一，就像一贯不激进的慕课网也在今年双11打出了下面的专题：

上车，任何时间都不晚！ 那么怎么才能踏上Go这一强大且稳健前行的车呢？和其他主流编程语言一样，上车的必经之路：看书！

2. 市面上的Go书籍为何这么少

和C、C++、Java、Python等编程语言在市面上的书籍数量相比，Go流行于市面（大陆）上的图书似乎少了很多。其原因笔者觉得有如下几点：

1) 年轻

我们来看看上述几门主流编程语言的诞生时间：

• java 1995

• c 1972

• c++ 1983

• python 1991

对于很多IT从业者来说，这些语言诞生的时候他们还没出生呢。而2009年末才正式发布的Go和“最年轻”的java之间还有14年的“年龄差”。

Go在国内真正开始快速流行起来大致在2015年第一届GopherChina大会(2015.4月)之后，当时的Go是1.4版本)。同一年下半年发布的Go 1.5实现自举并让GC延迟大幅下降，这引爆了Go在国内的流行。一批又一批程序员成为Gopher，在大厂、初创实践着Go语言。但知识和技能的沉淀和总结需要时间，相信再有5年，国内作者出版的Go语言相关书籍会像雨后春笋版出现在大家的书架上。

2）以品类代名词的身份占据的“领域”还少

提到Web，人们想到的是Java spring；提到深度学习、机器学习、人工智能，人们想到的是python和tensorflow；提到比特币，嵌入式，人们想到的是C；提到游戏，人们想到的是C++；提到前端，人们想到的是Javascript。这些语言在这些垂直领域早早以杀手级框架入场，使得它们成为了这一领域的“品类代名词”，因此与该垂直领域相关的技术书籍都会采用作为该领域“品类代名词”的编程语言编写书中示例等，这样的书也就会被归类为这类语言方面的书籍。

Go语言诞生晚，入场也较晚。Go虽然通过缓慢的“爬行”，覆盖了一些领域并占据优势地位，但还不能说已经成为了该领域的“品类代名词”，比如：云原生、API、微服务、区块链等，因此被垂直领域书籍关联的机会也不像上面那几门语言多。

同时，由于Go“自带电池”，基于Go标准库我们可以实现大部分功能特性，无需依赖过多框架。即便依赖框架，框架本身也不复杂，很少以“某某框架”为主题编写一本技术书籍，这方面远远无法媲美Java和Spring这对“黄金组合”。

3) 引进国外优秀作品需要时间

相对于国内，国外关于Go语言的作品要多不少，但引进国外图书资料需要时机以及时间(找译者翻译)。

3. 系统学习Go语言的书籍列表TOP 5

笔者接触Go语言较早，Go语言相关的中外文书籍几乎都通读过一遍（经典好书读过可不止一遍哦）。Go语言比较简单，如果单单从系统掌握这门语言的角度来看，阅读下面基本书籍就足够了。如果你要学习某些垂直领域的Go应用和技巧，那么期待我后续对垂直领域Go书籍/资料的推荐吧^_^。

这里参考“天下足球”TOP10栏目的方式推荐我心目中掌握Go语言必读的五大好书（每项满分为5分）！

第五名：《The Way To Go》 – Go语言百科全书

《The Way To Go》是我早期学习Go语言时最喜欢翻看的一本书。该书成书于2012年3月，恰逢Go 1.0版本刚刚发布，作者承诺书中代码均可在Go 1.0版本上编译通过并运行。该书分为4个部分：

• 为什么学习Go以及Go环境安装入门

• Go语言核心语法

• Go高级用法（读写、错误处理、单元测试、并发编程、socket与web编程等)

• Go应用(常见陷阱、语言应用模式、从性能考量的代码编写建议、现实中的Go应用等)

每部分的每个章节都很精彩，这本书也是目前见到的最全面详实的讲解Go语言的书籍了，我称之为Gopher们的第一本“Go百科全书”。

该书作者Ivo Balbaert想必大多数人都不曾耳闻。为了写本文，我特地研究了一下他的作品以及出版时间，发现这个技术作者是很会“抢先机”并且眼光独到。他总是能发现市面刚出现不久但却很有潜力的编程语言并在其他人了解该门语言之前，就编写出类似“The way to Go”这样的为早期语言接纳者提供的详实资料，包括Julia，Rust等。在很多人还不知道这些语言名字的时候，他就已经开始学习这些语言，并为这些语言编写出质量很高的“百科全书”式的书籍。

很遗憾，这本书没有中文版。这可能是由于本书出版太早，等国内出版社意识到要引进Go语言方面的书籍时，这本书使用的Go版本又太老了，虽然本书中绝大部分例子依然可以在今天最新的Go编译器下通过编译并运行起来。不过无闻在github上发起了这本书的中译版项目：https://github.com/Unknwon/the-way-to-go_ZH_CN，感兴趣的gopher可以去在线或下载阅读。
此书虽棒，但毕竟年头“久远”，我只能委屈它一下了，将它列在第五位，下面是其各个指数的评分：

• 作者名气指数：3

• 关注度指数：3

• 内容实用指数：4

• 经典指数：4

总分：14

第四名：《Go 101》 – Go语言规范全方位解读

这是一本在国外人气和关注度比在国内高的中国人编写的英文书，当然也是有中文版的。

如果仅从书名中的101去判断，你很大可能会认为这仅仅是一本讲解Go入门基础的书，但这本书的内容可远远不止入门这么简单。这本书可大致分为三个部分：

• Go语法基础

• Go类型系统与运行时实现

• 以专题(topic)形式阐述的Go特性、技巧与实践模式

除了第一部分算是101范畴，其余两个部分都是Go语言的高级话题，也是要精通Go必须要掌握的“知识点”。并且，结合Go语言规范，作者对每个知识点的阐述都细致入微并结合大量示例辅助说明。我们知道有关C和C++语言，市面上有一些由语言作者或标准规范委员会成员编写的annotated或rationale书籍（语言参考手册或标准解读），Go 101这本书也可以理解为Go语言的标准解读或参考手册。

Go 101这本书是开源电子书，其作者也在国外一些支持自出版的服务商那里做了付费数字出版。这使得这本书相对于其他纸板书有着另外一个优势：与时俱进。在作者的不断努力下，该书的知识点更新基本保持与Go的演化同步，目前其内容已经覆盖了最新的Go 1.15版本。

该书作者为国内资深工程师老貘，他花费三年时间“呕心沥血”完成此书并免费奉献给Go社区，值得大家为其大大的点赞！
下面是本书推荐指数的评分：

• 作者名气指数：3

• 关注度指数：4

• 内容实用指数：4

• 经典指数：4

总分：15

第三名：《Go语言学习笔记》 – Go源码剖析与实现原理探索

这是一本在国内影响力很大和关注度较高的作品。一来其作者雨痕老师是国内资深工程师，也是2015年第一届GopherChina大会讲师；二来，该作品的前期版本是以开源电子书的形式风险给国内Go社区的；三来，作者在Go源码剖析方便可谓之条理清晰，细致入微。

2016年《Go语言学习笔记》纸版书出版，该书覆盖了当时最新的Go 1.5版本，Go 1.5版本在Go语言演化历史中的分量极高，它不仅实现了Go自举，还让Go GC的延迟下降到绝大多数应用可以将其应用到生产的程度。本书整体上分为两大部分：

• Go语言详解：以短平快、捞干的来的风格对Go语言语法做了说明，能用示例说明的，绝不用文字做过多修饰。

• Go源码剖析：这是本书精华，也是最受Gopher关注的部分。这部分对Go运行时神秘的内存分配、垃圾回收、并发调度、channel和defer的实现原理、syn.Pool的实现原理做了细致的源码剖析与原理总结。

随着Go语言演化，其语言和运行时实现一直在变化，但Go 1.5版本的实现是后续版本的基础，因此这本书的剖析非常值得每位Gopher阅读。从雨痕老师的github上最新消息来看，他似乎在编写新版Go语言学习笔记，基于Go 1.12版本，剖析源码是枯燥繁琐的，期待新版Go学习笔记早日与Gopher们见面。
下面是本书各个指数的评分：

• 作者名气指数：4

• 关注度指数：4

• 内容实用指数：4

• 经典指数：4

总分：16

第二名：《Go语言实战》 – 实战系列(in action)经典之作，紧扣Go语言的精华

Manning出版社出版的“实战系列(xx in action)”一直是程序员心中高质量和经典的代名词。在出版Go语言实战方面，该出版社也是丝毫不敢怠慢，邀请了Go社区知名的三名明星级作者联合撰写了该书的内容。这三位作者分别是：

• 威廉·肯尼迪 (William Kennedy) – 知名Go培训师，培训机构Ardan Labs的联合创始人，”Ultimate Go”培训的策划实施者。

• 布赖恩·克特森 (Brian Ketelsen) – 世界上最知名的Go技术大会 – GopherCon大会的联合发起人和组织者，GopherAcademy创立者，现微软Azure工程师

• 埃里克·圣马丁 (Erik St.Martin) – 世界上最知名的Go技术大会 – GopherCon大会的联合发起人和组织者

本书并不是大部头，而是薄薄的一本（中文版才200多页），因此你不要期望从本书得到百科全书一样的阅读感。本书的作者们显然也没有想将其写成面面俱到的作品，而是直击要点，即挑出Go语言和其他语言相比与众不同的特点进行着重讲解，这些特点构成了本书的结构框架：

• 入门：快速上手搭建、编写、运行一个go程序

• 语法：数组(作为一个类型而存在)、切片和map

• Go类型系统的与众不同：方法、接口、嵌入类型

• Go的拿手好戏：并发及并发模式

• 标准库常用包：log、marshal/unmarshal、io(Reader和Writer)

• 原生支持的测试

读完这本书，你就掌握了Go语言的精髓之处，这迎合了多数gopher的内心需求。本书中文版译者Googol Lee也是Go圈子里的资深gopher，翻译质量上乘。

下面对本书各个指数的评分：

• 作者名气指数：5

• 关注度指数：5

• 内容实用指数：4

• 经典指数：4

总分：18

第一名：《Go程序设计语言》 – 人手一本的Go语言“圣经”

如果说由Brian W. Kernighan和Dennis M. Ritchie联合编写的《The C Programming Language》(也称K&R C)是C程序员(甚至是所有程序员)心目中的“圣经”的话，

那么同样由Brian W. Kernighan(K)参与编写的《The Go Programming Language》（也称tgpl）就是Go程序员心目中的“圣经”。

本书模仿并致敬“The C Programming Language”的经典结构，从一个”hello, world”示例开始带领大家开启Go语言之旅。第二章程序结构是Go语言这个“游乐园”的向导图，了解它之后，我们就会迫不及待地奔向各个“景点”细致参观。Go语言规范中的所有“景点”在本书中都被覆盖到了，并且由浅入深，循序渐进：从基础数据类型到复合数据类型、从函数、方法到接口、从创新的并发goroutine到传统的基于共享变量的并发，从包、工具链到测试，从反射到低级编程(unsafe包)。作者行文十分精炼，字字珠玑，这与《The C Programming Language》的风格保持了高度的一致。书中的示例在浅显易懂的同时，又极具实用性并突出Go语言的特点（比如：并发web爬虫、并发非阻塞缓存等）。

读完本书后，你会有一种爱不释手，马上还要从头再读一遍的感觉，也许这就是“圣经”的魅力！

本书出版于2015年10月26日，也是既当年中旬Go 1.5这个里程碑版本发布后，Go社区的又一重大历史事件！并且Brian W. Kernighan老爷子的影响力让更多程序员加入到Go阵营，这也或多或少促成了Go成为下一个年度，即2016年年度TIOBE最佳编程语言。能得到Brian W. Kernighan老爷子青睐的编程语言只有C和Go，这也是Go的幸运。当然了如果老爷子是被Rob Pike或Ken Thompson通过私人关系邀请写书的，那就另当别论了，当然这纯属臆测，别当真^_^。

这本书的另一名作者Alan A. A. Donovan也并非等闲之辈，他是Go核心开发团队的成员，专注于Go工具链方面的开发。

现在唯一遗憾的是Brian W. Kernighan老爷子年事已高，不知道Go加入泛型后老爷子是否还有精力更新这本圣经。

该书中文版由七牛团队翻译，总体质量是不错的。建议Gopher们人手购置一本圣经“供奉”起来！^_^

下面对本书各个指数的评分：

• 作者名气指数：5

• 关注度指数：5

• 内容实用指数：5

• 经典指数：5

总分：20

4. 小结

Go书籍绝非“汗牛充栋”，预计Go增加泛型表达力增强后，市面上会有更多的技术书籍出炉。上面的某些经典也许还会出新版。而市面上Go书籍不多从另外一角度也可以理解成Go语言在国内还有巨大的发展空间与潜力。

努力吧，Gopher们！

只有写书者，才能体会到写者的艰辛！Go专栏：《改善Go语言编程质量的50个有效实践》也是我努力了一年多才打磨雕琢出来的心血之作。自从上线后，收到大家的热烈关注和好评！现在恰逢双11慕课大促，欢迎有意愿在Go这条技术路线上进阶的朋友们订阅，在学习过程中欢迎随时反馈和交流！

我的网课“Kubernetes实战：高可用集群搭建、配置、运维与应用”在慕课网热卖中！欢迎小伙伴们学习支持！双十一慕课网优惠空前！别错过机会哦！

微博：https://weibo.com/bigwhite20xx
微信公众号：iamtonybai
博客：tonybai.com
github: https://github.com/bigwhite

微信赞赏：

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

本文翻译自《Illustrated Tales of Go Runtime Scheduler》。

译注：原文章结构有些乱，笔者自行在译文中增加了一些分级标题，让结构显得更清晰一些:)。

多goroutines形式的Go并发是编写现代并发软件的一种非常方便的方法，但是您的Go程序是如何高效地运行这些goroutines的呢？

在这篇文章中，我们将深入Go运行时底层，从设计角度了解Go运行时调度程序是如何实现其魔法的，并运用这些原理去解释在Go性能调试过程中产生的Go调度程序跟踪信息。

所有的工程奇迹都源于需要。因此，要了解为什么需要一个Go运行时调度程序以及它是如何工作的，我们可以让时间回到操作系统兴起的那个时代，回顾操作系统的历史可以使我们深入的了解问题的根源。如果不了解问题的根源，就没有解决它的希望。这就是历史所能做的。

一. 操作系统的历史

1. 单用户（无操作系统）。
2. 批处理，独占系统，直到运行完成。
3. 多道程序(译注:允许多个程序同时进入内存并运行)

多道程序的目的是使CPU和I/O重叠(overlap)。(译注:多道程序出现之前，当操作系统执行I/O操作时，CPU是空闲的；多道程序的引入实现了在一个程序占用CPU的时候，另一个程序在执行I/O操作)

那怎么实现多道程序(的CPU与I/O重叠)呢？两种方式:多道批处理系统和分时系统。

• 多道批处理系统

  • IBM OS/MFT（具有固定数量的任务的多道程序）
  • IBM OS/MVT（具有可变数量的任务的多道程序）在这里，每个作业(job)仅获得其所需的内存量。随着job的进出，内存的划分会发生变化。

• 分时

  • 这是一种多道程序设计，可以在作业之间快速切换。决定何时切换以及切换到哪个作业的过程就称为调度(scheduling)。

当前，大多数操作系统使用分时调度程序。

那么这些调度程序将用来调度什么实体(entity)呢？

• 不同的正在执行的程序（即进程process）
• 或作为进程子集存在使用CPU的基本单元:线程

但是在这些实体的切换是有代价的。

• 调度成本

因此，使用一个包含多个线程的进程的效率更高，因为进程创建既耗时又耗费资源。但是随后出现了多线程问题:C10k成为主要问题。

例如，如果将调度周期定为10ms（毫秒），并且有2个线程，则每个线程将分别获得5ms。如果您有5个线程，则每个线程将获得2ms。但是，如果有1000个线程怎么办？给每个线程一个10μs（微秒）的时间片？错，这样做很愚蠢，因为您将花费大量时间进行上下文切换，但是真正要完成的工作却进展缓慢或停滞不前。

您需要限制时间片的长度。在最后一种情况下，如果最小时间片为2ms并且有1000个线程，则调度周期需要增加到2s（10002ms）。如果有10,000个线程，则调度程序周期为20秒(100002ms)。在这个简单的示例中，如果每个线程都将分配给它的时间片用完，那么所有线程都完成一次运行需要20秒。因此，我们需要一些可以使并发成本降低而又不会造成过多开销的东西。

• 用户层线程
  • 线程完全由运行时系统（用户级库）管理。
  • 理想情况下，快速高效:切换线程的代价不比函数调用多多少。
  • 操作系统内核对用户层线程一无所知，并像对待单线程进程(single-threaded process)一样对其进行管理。

在Go中，我们知道这样的用户层线程被称为“Goroutine”。

• Goroutine

goroutine是由Go运行时管理的轻量级线程（lightweight thread）。要启动一个新的goroutine，只需在函数前面使用go关键字:go add(a, b)。

• Goroutine之旅

func main() {
    var wg sync.WaitGroup
    for i := 0; i <= 10; i++ {
        wg.Add(1)
        go func(i int) {
        defer wg.Done()
        fmt.Printf("loop i is - %d\n", i)
        }(i)
    }
    wg.Wait()
    fmt.Println("Hello, Welcome to Go")
}

https://play.golang.org/p/73lESLiva0A

您能猜出上面代码片段的输出吗？

loop i is - 10
loop i is - 0
loop i is - 1
loop i is - 2
loop i is - 3
loop i is - 4
loop i is - 5
loop i is - 6
loop i is - 7
loop i is - 8
loop i is - 9
Hello, Welcome to Go

如果我们看一下输出的一种组合，你可能马上就会有两个问题:

• 11个goroutine如何并行运行？魔法？
• goroutine以什么顺序运行？

上面的这两个提问给我们带来了问题。

• 问题概述
  • 如何将这些goroutines分配到在CPU处理器上运行的多个操作系统线程上运行？
  • 这些goroutines应该以什么顺序运行才能保证公平？

本文后续的讨论将主要围绕Go运行时调度程序从设计角度如何解决这些问题。但是，与所有问题一样，我们的讨论也需要定义一个明确的边界。否则，问题陈述可能太含糊，无法形成结论。调度程序可能针对多个目标中的一个或多个，对于我们来说，我们将自己限制在以下需求之内:

1. 应该是并行、可扩展且公平的。
2. 每个进程应可扩展到数百万个goroutine（C10M）
3. 内存利用率高。（RAM很便宜，但不是免费的。）
4. 系统调用不应导致性能下降。（最大化吞吐量，最小化等待时间）

让我们开始为调度程序建模，以逐步解决这些问题。

二. Goroutine调度程序模型 (译者自行加的标题)

1. 模型概述(译者自行加的标题)

a) 一个线程执行一个Goroutine

局限性:

• 并行和可扩展
  • 并行（是的）
  • 可扩展（不是真的）
• 每个进程不能扩展到数百万个goroutine（C10M）。

b) M:N线程—混合线程

M个操作系统内核线程执行N个“goroutine”

实际执行代码和并行执行都需要内核线程。但是线程创建起来很昂贵，因此我们将N个goroutines映射到M个内核线程上去执行。Goroutine是Go代码，因此我们可以完全控制它。而且它在用户空间中，创建起来很便宜。

但是由于操作系统对goroutine一无所知。因此每个goroutine都有一个状态，以帮助调度器根据goroutine状态知道要运行哪个goroutine。与内核线程的状态信息相比，goroutine的状态信息很小，因此goroutine的上下文切换变得非常快。

• 正在运行(Running) – 当前在内核线程上运行的goroutine。
• 可运行(Runnable) – 等待内核线程来运行的goroutine。
• 已阻塞(Blocked) – 等待某些条件的Goroutine（例如，阻塞在channel操作，系统调用，互斥锁上的goroutine）

因此，Go运行时调度器通过将N个Goroutine多路复用到M个内核线程的方式来管理处于各种不同状态的goroutines。

2. 简单的M:N调度器

在我们简单的M:N调度器中，我们有一个全局运行队列(global run queue)，某些操作将一个新的goroutine放入运行队列。M个内核线程访问调度程序从“运行队列”中获取并运行goroutine。多个线程正在尝试访问相同的内存区域，因此使用互斥锁来同步对该运行队列的访问。

但是，那些已阻塞的goroutine在哪里？

下面是goroutine可能会阻塞的情况：

1. 在channel上发送和接收
2. 网络I/O操作
3. 阻塞的系统调用
4. 使用定时器
5. 使用互斥锁

那么我们将这些阻塞的goroutine放在哪里呢？— 将这些阻塞的goroutine放置在哪里的设计决策基本上是围绕一个基本原理进行的：

阻塞的goroutine不应阻塞底层内核线程！（避免线程上下文切换的成本）

channel操作期间阻塞的Goroutine

每个channel都有一个recvq(waitq)，用于存储试图从该channel读取数据而阻塞的goroutine。

Sendq(waitq)存储试图将数据发送到channel而被阻止的goroutine 。（channel实现原理:-https://codeburst.io/diving-deep-into-the-golang-channels-549fd4ed21a8）

channel本身会将channel操作后的未阻塞goroutine放入“运行”队列(run queue)。

那系统调用呢？

首先，让我们看一下阻塞系统调用。系统调用会阻塞底层内核线程，因此我们无法在该线程上调度任何其他Goroutine。

隐含阻塞系统调用可降低并行度。

一旦发生阻塞系统调用，我们无法再在M2线程上安排任何其他Goroutine运行，从而导致CPU浪费。由于我们有工作要做，但没法运行它。

恢复并行度的方法是在进入系统调用时，我们可以唤醒另一个线程，该线程将从运行队列中选择可运行的goroutine。

但是现在，系统调用完成后，我们有超额等待调度的goroutine。因此，我们不会立即运行从阻塞系统调用中返回的goroutine。我们会将其放入调度程序的运行队列中。

因此，在程序运行时，线程数远大于cpu核数。尽管没有明确说明，线程数大于cpu核数，并且所有空闲线程也由运行时管理，以避免启动过多的线程。

https://golang.org/pkg/runtime/debug/#SetMaxThreads

初始设置为10,000个线程，如果超过10,000个线程，程序将崩溃。

非阻塞系统调用-将goroutine阻塞在Integrated runtime poller上 ，并释放线程以运行另一个goroutine。

例如，在非阻塞I/O（例如HTTP调用）的情况下。由于资源尚未准备就绪，第一个syscall将不会成功，这将迫使Go使用network poller并将goroutine暂停。

部分net.Read函数的实现：

    n, err := syscall.Read(fd.Sysfd, p)
        if err != nil {
            n = 0
            if err == syscall.EAGAIN && fd.pd.pollable() {
                if err = fd.pd.waitRead(fd.isFile); err == nil {
                    continue
                }
            }
    }

一旦完成第一个系统调用并明确指出资源尚未准备就绪，goroutine将暂停，直到network poller通知它资源已准备就绪。在这种情况下，线程M将不会被阻塞。

Poller将基于操作系统使用select/kqueue/epoll/IOCP等机制来知道哪个文件描述符已准备好，一旦文件描述符准备好进行读取或写入，它将把goroutine放回到运行队列中。

还有一个Sysmon OS线程，如果超过10ms未轮询网络，它就将定期轮询网络，并将已就绪的G添加到队列中。

基本上所有goroutine都被阻塞在下面操作上：

1. channel
2. 互斥锁
3. 网络IO
4. 定时器

有某种队列，可以帮助调度这些goroutine。

现在，运行时拥有具有以下功能的调度程序。

• 它可以处理并行执行（多线程）。
• 处理阻塞系统调用和网络I/O。
• 处理阻塞在用户级别（在channel上）的调用。

但这不是可伸缩的(scalable)。

您可以通过Mutex同步全局运行队列，但最终会遇到一些问题，例如

1. 缓存一致性保证的开销。
2. 在创建，销毁和调度Goroutine G时进行激烈的锁竞争。

使用分布式调度程序解决可伸缩性问题。

分布式调度程序-每个线程一个运行队列

这样，我们可以看到的直接好处是，每个线程的本地运行队列(local run queue)现在都没有使用mutex。仍然有一个带有mutex的全局运行队列，但仅在特殊情况下使用。它不会影响可伸缩性。

但是现在，我们有多个运行队列。

1. 本地运行队列
2. 全局运行队列
3. 网络轮询器(network poller)

我们应该从哪里运行下一个goroutine？

在Go中，轮询顺序定义如下：
1. 本地运行队列
2. 全局运行队列
3. 网络轮询器
4. 工作偷窃(work stealing)

即首先检查本地运行队列，如果为空则检查全局运行队列，然后检查网络轮询器，最后进行“偷窃工作”。到目前为止，我们对1,2,3有了一些概述。让我们看一下“工作偷窃(work stealing)”。

工作偷窃

如果本地工作队列为空，请尝试“从其他队列中偷窃工作”

当一个线程有太多工作要做而另一个线程空闲时，工作偷窃可以解决这个问题。在Go中，如果本地队列为空，工作偷窃将尝试满足以下条件之一。

• 从全局队列中拉取工作。
• 从网络轮询器中拉取工作
• 从其他线程的本地队列中偷窃工作

到目前为止，Go运行时的调度器具有以下功能：

• 它可以处理并行执行（使用多线程）。
• 处理阻塞系统调用和网络I/O。
• 处理用户级别（比如：在channel）的阻塞调用。
• 可伸缩扩展(scalable)

但这仍不是最有效的。

还记得我们在阻塞系统调用中恢复并行度的方式吗？

它暗示在一个系统调用中我们可以有多个内核线程（可以是10或1000），这可能会比cpu核数多很多。这个方案将最终在以下期间产生了恒定的开销:

• 偷窃工作时，它必须同时扫描所有内核线程（空闲的和运行goroutine的）本地运行队列，并且大多数都将是空闲的。
• 垃圾回收，内存分配器都会遇到相同的扫描问题。（https://blog.learngoprogramming.com/a-visual-guide-to-golang-memory-allocator-from-ground-up-e132258453ed）

使用M:P:N线程克服效率问题。

M:P:N（3级调度程序）— 引入逻辑处理器P

P —表示处理器，可以将其视为在线程上运行的本地调度程序

逻辑进程P的数量始终是固定的。（默认为当前进程可以使用的逻辑CPU数量）

然后，我们将本地运行队列（LRQ）放入固定数量的逻辑处理器（P）中(译者注：而不是每个内核线程一个本地运行队列)。

Go运行时将首先根据计算机的逻辑CPU数量（或根据请求）创建固定数量的逻辑处理器P。

每个goroutine（G）将在分配了逻辑CPU（P）的OS线程（M）上运行。

所以现在我们在以下期间没有了恒定的开销:

• 偷窃工作 -只需扫描固定数量的逻辑处理器（P）的本地运行队列。
• 垃圾回收，内存分配器也将获得相同的好处。

使用固定逻辑处理器（P）的系统调用呢？

Go通过将它们包装在运行时中来优化系统调用（无论是否阻塞）。

阻塞SYSCALL方法封装在runtime.entersyscall(SB)和 runtime.exitsyscall(SB)之间。

从字面上看，某些逻辑在进入系统调用之前被执行，而某些逻辑在系统调用返回之后执行。进行阻塞的系统调用时，此包装器将自动将P与线程M(即将执行阻塞系统调用的线程)解绑，并允许另一个线程在其上运行。

这使得Go运行时可以高效地处理阻塞的系统调用，而无需增加运行队列(译注：本地运行队列数量始终是和P数量一致的)。

一旦阻塞系统调用返回，会发生什么？

• 运行时会尝试获取之前绑定的那个P，然后继续执行。
• 运行时尝试在P空闲列表中获取一个P并恢复执行。
• 运行时将goroutine放在全局队列中，并将关联的M放回M空闲列表。

自旋线程和空闲线程

当M2线程在syscall返回后变得空闲时。如何处理这个空闲的M2线程。从理论上讲，如果线程完成了所需的操作，则应将其销毁，然后再安排进程中的其他线程到CPU上执行。这就是我们通常所说的操作系统中线程的“抢占式调度”。

考虑上述syscall中的情况。如果我们销毁了M2线程，而同时M3线程即将进入syscall。此时，在OS创建新的内核线程并将其调度执行之前，我们无法处理可运行的goroutine。频繁的线程前抢占操作不仅会增加OS的负载，而且对于性能要求更高的程序几乎是不可接受的。

因此，为了适当地利用操作系统的资源并防止频繁的线程抢占给操作系统带来的负担，我们不会销毁内核线程M2，而是使其执行自旋操作并以备将来使用。尽管这看起来是在浪费一些资源。但是，与线程之间的频繁抢占以及频繁的创建和销毁操作相比，“空闲线程”要付出的代价更少。

Spinning Thread(自旋线程) — 例如，在具有一个内核线程M（1）和一个逻辑处理器（P）的Go程序中，如果正在执行的M被syscall阻塞，则运行时会请求与P数量相同的“Spinning Threads”以允许等待的可运行goroutine继续执行。因此，在此期间，内核线程的数量M将大于P的数量（自旋线程+阻塞线程）。因此，即使将runtime.GOMAXPROCS的值设置为1，程序也将处于多线程状态。

调度中的公平性如何？—公平地选择下一个要执行的goroutine

与许多其他调度程序一样，Go也具有公平性约束，并且由goroutine的实现所强加，因为Runnable goroutine应该最终得到调度并运行。

这是Go Runtime Scheduler的四个典型的公平性约束：

任何运行时间超过10ms的goroutine都被标记为可抢占（软限制）。但是，抢占仅在函数执行开始处才能完成。Go当前在函数开始处中使用了由编译器插入的协作抢占点。

• 无限循环 – 抢占（约10毫秒的时间片）- 软限制

但请小心无限循环，因为Go的调度程序不是抢先的（直到Go 1.13）。如果循环不包含任何抢占点（例如函数调用或分配内存），则它们将阻止其他goroutine的运行。一个简单的例子是:

package main

func main() {
    go println("goroutine ran")
    for {}
}

如果你运行:

GOMAXPROCS=1 go run main.go

直到Go（1.13）才可能打印该语句。由于缺少抢占点，main Goroutine将独占处理器。

• 本地运行队列 -抢占（〜10ms时间片）- 软限制
• 通过每61次调度就检查一次全局运行队列，可以避免全局运行队列处于“饥饿”状态。
• 网络轮询器饥饿 后台线程会在主工作线程未轮询的情况下偶尔会轮询网络。

Go 1.14有一个新的“非合作抢占”机制。

有了这种机制，Go运行时便有了具有所有必需功能的Scheduler。

• 它可以处理并行执行（多线程）。
• 处理阻塞系统调用和网络I/O。
• 处理用户级别（在channel上）的阻塞调用。
• 可扩展
• 高效
• 公平

这提供了大量的并发性，并且始终尝试实现最大的利用率和最小的延迟。

现在，我们总体上对Go运行时调度程序有了一些了解，我们如何使用它？Go为我们提供了一个跟踪工具，即调度程序跟踪(scheduler trace)，目的是提供有关调度行为的信息并用来调试与goroutine调度器伸缩性相关的问题。

三. 调度器跟踪

使用GODEBUG=schedtrace=DURATION环境变量运行Go程序以启用调度程序跟踪。（DURATION是以毫秒为单位的输出周期。）

有关调度器跟踪的内容，Go Wiki拥有更多信息。

参考:Dmitry Vyukov的可扩展Go Scheduler设计文档和演讲 https://docs.google.com/document/d/1TTj4T2JO42uD5ID9e89oa0sLKhJYD0Y_kqxDv3I3XMw/edit

Gopher艺术作品致谢:Ashley Mcnamara。

我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了，感谢小伙伴们学习支持！

我爱发短信:企业级短信平台定制开发专家 https://tonybai.com/
smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展； 短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

微博:https://weibo.com/bigwhite20xx
微信公众号:iamtonybai
博客:tonybai.com
github: https://github.com/bigwhite

微信赞赏:

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。