2020年二月月 发布的文章

Go语言之禅

本文翻译自Go社区知名Gopher和博主Dave Cheney的文章《The Zen of Go》

img{512x368}

本文来自我在GopherCon Israel 2020上的演讲。文章很长:) 如果您希望阅读精简版,请移步到the-zen-of-go.netlify.com

该演讲视频还未上线。如上线,我会把它更新到本文中的。

我应该如何编写出好代码?

我最近一直在思考很多事情,每当反思自己的工作成果时,眼前常会出现一行字幕:我该如何编写出好代码? 主观上,没人愿意去编写糟糕的代码,那么问题来了:你是怎么知道你编写出好的Go代码了呢?

如果好与坏之间存在连续性,那么我们怎么知道哪些是好的部分?它的特性、属性、标志、模式和惯用法又是什么呢?

Go语言惯用法(idiomatic Go)

img{512x368}

这让我走进Go惯用法。说某种东西是惯用的,就是说它遵循了时代的风格。如果某些东西不是惯用的,那它没有遵循流行的风格,感觉不时髦。

更重要的是,对某人说他们的代码不复合惯用法并不能解释为什么这些代码不符合惯用法。为什么会这样?像所有真相一样,答案可以在词典中找到:

idiom (noun): a group of words established by usage as having a meaning not deducible from those of the individual words.
惯用法(名词):一组由用法确定的且其含义无法从单个单词的含义中推导出来的单词。

惯用法是共享价值观(value)的标志。Go惯用法不是您从书本中学到的东西,而是通过成为社区的一部分而获得的

img{512x368}

Go惯用法字样用多了,便形成了“口头禅”,这引起我的担忧:这种口头禅在许多方面它可能是具有排他性的。比如:有人说“你不能和我们坐在一起。” 但毕竟这不是我们批评某人的代码不符合惯用法时的索要表达的意思,是吧?他们只是没有做对,看起来不对,它没有遵循流行的风格而已。

我认为Go惯用法不是教如何编写好的Go代码的合适机制,因为从根本上说,它仍然告诉某人做错了(译注:这容易引起对方反感)。如果在他们最愿意接受建议的时候,我们给出让他们不感觉疏远的建议是否会更好些?

谚语(Proverbs)

摆脱有问题的惯用法,Gopher们还有哪些其他的文化手工艺品吗?也许我们可以转向Rob Pike精彩的Go 谚语。这些谚语是合适的教学工具吗?它们会告诉Go新手如何编写好的Go代码吗?

总的来说,我不这么认为。这并不是要驳斥Rob Pike的作品。只是像濑越宪作(Segoe Kensaku)的原著一样,Go谚语只是观察,而不是价值观的陈述。我们再次搬出字典:

proverb (noun): a short, well-known pithy saying, stating a general truth or piece of advice.
谚语(名词):简短而众所周知的俗语,陈述一般的真理或一段忠告。

Go Proverbs的目的是揭示有关语言设计的更深层次的真理,但是像empty interface says nothing这样的建议对于一个来自商没有结构化类型的语言的新手来说有什么用呢?

重要的是要认识到,在一个不断发展的社区中,任何时候学习Go语言的人的数量都远超过那些声称掌握了该语言的人的数量。因此,在这种情况下,谚语可能也不是最佳的教学工具。

工程价值观

丹·卢(Dan Luu)找到了马克·卢科夫斯基(Mark Lucovsky)关于Windows团队在Windows NT-Windows 2000开发阶段时的工程文化的演讲。我之所以提到它,是因为卢科夫斯基将一种文化描述为一种评估设计和权衡取舍的常用方法。

img{512x368}

讨论文化的方法有很多,但是就工程文化而言,Lucovsky的描述是恰当的。其中心思想是在未知的设计空间中用价值观指导决策。Windows NT团队的价值观是:可移植性,可靠性,安全性和可扩展性。粗略地说工程价值观就是在这里完成工作的方式。

Go的价值观

Go的显式价值观是什么呢?定义Go程序员解释世界方式的核心信念或哲学又是什么?他们如何发布宣传?他们怎么传授?如何执行?它们又是如何随着时间变化的?

作为新Go程序员,您将如何被灌输Go的工程价值观?或者,你是一位经验丰富的Go专家,你如何将你的价值观传播给“下一代”?就像我们知道的那样,知识传递的过程不是一个可选项。没有新的血液和新的观念,我们的社区将变得短视和枯萎。

其他语言的价值观

为了给我所要了解的场景做铺垫,我们可以先看看其他语言,我们看看它们的工程价值观。

例如,C++(包括其扩展:Rust)认为程序员不必为自己不使用的特性付费。如果程序未使用该语言的某些计算成本昂贵的特性,则不应强迫该程序承担该特性的成本。该价值观从语言扩展到其标准库,并用作判断所有用C++编写的代码设计的标准。

在Java,Ruby和Smalltalk中,一切都是对象的核心价值观驱动着围绕着消息传递,信息隐藏和多态的程序设计风格。在程序中采用过程式或函数式设计风格会被认为是错误的,或者按照Gophers的说法,是不符合惯用法的。

回到我们自己的Go社区,烙印在Go程序员心中的工程价值观是什么呢?在我们社区中的讨论是很容易引战的,因此要从第一条原则衍生出一套价值观念将是一个巨大的挑战。共识很关键,但随着讨论贡献者数量的增加,难度就成倍增加。但是,如果有人已经为我们完成了这些艰苦的工作了呢?

~~Python~~ Go之禅

几十年前,蒂姆·彼得斯(Tim Peters)坐下来写下了PEN-20(Python之禅)。Peters试图记录他认为Guido van Rossum(Python之父)在Python社区扮演的BDFL(仁慈的独裁者)角色时所应用的工程价值观。

在本文的剩余部分中,我将着眼于Python之禅,并问问大家:是否有什么可以用来揭秘Go程序员的工程价值观的?

一个好的package始于一个好名字

让我们从香辛的东西开始

“Namespaces are one honking great idea–let’s do more of those!” The Zen of Python, Item 19
“命名空间是一个很棒的主意-让我们多做些吧!” Python之禅,条款19

这是相当明确的,Python程序员应该使用命名空间,多多益善。

package就是Go语言的命名空间。我怀疑是否有人质疑将组件分组到程序包中利好设计和潜在重用。但关于这么做的正确方法的困惑肯定会有的,尤其是你拥有另一门语言10年的使用经验。

在Go中,每个程序包都应有一个目的/用途,而了解程序包目的/用途的最佳方法是通过其名字-一个名词。包的名字描述了它提供的内容。因此,这里重新解释一下Peters的话:每个Go软件包(package)都应该仅有一个单一的目的/用途。

这不是一个新主意,我已经说了一段时间了,但是为什么要这样做而不是使用将软件包用于细粒度分类的方法呢?为什么,因为变化(change)。

“Design is the art of arranging code to work today, and be changeable forever.” - Sandi Metz
“设计是安排代码以使其至今天仍然可以工作并且永远可以更改的艺术。” - 桑迪·梅斯

变化是我们所从事的游戏的名称(译注:这里的游戏指代程序开发工作)。作为程序员,我们要做的就是管理变变化。当我们做得很好时,我们称之为设计或架构。当我们做得不好时,我们称其为技术债务或遗留代码。

如果你编写的程序对于一组固定的输入可以一次性地完美地工作,那么没人会在乎代码的好坏,因为最终程序的输出才是企业和业务所关心的。

但这是不正确的。软件具有缺陷(bug),需求变更,输入变更,并且很少有程序被编写为仅执行一次,因此您的程序会随着时间而变化。可能是您要为此承担任务,更有可能是其他人,但是必须更改该代码。有人必须维护该代码。

那么,如何使程序更改变得容易呢?无所不在的接口?使一切变得易于mock?邪恶的依赖注入(译注:作者对DI似乎很排斥,用了带有感情色彩的词汇)?好吧,也许,对于某类程序,但不是很多,这些技术将很有用。但是,对于大多数程序而言,预先设计一些灵活的方法要比工程设计更为重要。

相反,如果我们采取的立场是取代组件而不是增强组件,该怎么办?知道何时需要更换某些物品的最佳方法是什么时候该物品没有按照锡盒/罐头盒上的说明进行操作。

一个好的包始于选择一个好的名字。把你的包名字想象成电梯游说(Elevator pitch,即用极具吸引力的方式简明扼要地阐述自己的观点), 仅用一个词就可以描述包的内容。当名字不再符合要求时,请查找替代名字。

简单性很重要

“Simple is better than complex.” - The Zen of Python, Item 3
“简单胜于复杂。” - Python之禅,条款3

PEP-20说:简单胜于复杂,我完全同意。几年前,我发布了这条推文:

大多数编程语言开始都是为了简单,但最终只是为了功能强大而努力。— Dave Cheney(@davecheney)2014年12月2日

至少在当时,我的观察是,我想不出一生中使用的哪门语言不标榜着简单。每种新语言都为其固有的简单性提供了理由和诱因。但是,当我研究时,我发现简单性并不是与Go语言同时代的许多现代语言的核心价值观。也许这只是一个便宜的镜头1,但是可能是这些语言不是很简单,或者它们不认为自己很简单。他们不认为简单是其核心价值观。

但是什么时候简单变得过时了?为什么商业软件开发行业会忘记这个基本原则?

“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.” - C. A. R. Hoare, The Emperor’s Old Clothes, 1980 Turing Award Lecture

“构建软件设计的方式有两种:一种方式是使其变得如此简单,以至于显然没有缺陷,另一种方式是使得它变得如此复杂以至于没有明显的缺陷。第一种方法要困难得多。” - CAR Hoare,皇帝的旧衣,1980年图灵奖演讲

我们知道:简单并不意味着容易。通常,使某些东西易于使用而不是易于构建需要更多的工作。

“Simplicity is prerequisite for reliability.” - Edsger W Dijkstra, EWD498, 18 June 1975
“简单性是可靠性的前提。”-  埃兹格·迪克斯特拉(Essger W Dijkstra),EWD498,1975年6月18日

我们为什么要追求简单?为什么Go程序简单很重要?简单并不意味着粗糙,它意味着可读性和可维护性。简单并不意味着“不复杂”,它意味着可靠,有共鸣且易于理解。

“Controlling complexity is the essence of computer programming.” - Brian W. Kernighan, Software Tools (1976)
“控制复杂性是计算机编程的本质。” - Brian W. Kernighan,软件工具  (1976)

Python是否遵守其简单性的说法尚有争议,但Go坚持将简单性作为核心价值观。我认为我们都可以认同,就Go而言,简单代码比聪明代码更可取

避免包级别状态

“Explicit is better than implicit.” - The Zen of Python, Item 2
“显式胜于隐式。” - Python的禅宗,第2项

我认为彼得斯在这个地方的抱负胜于实际。Python中的许多内容并不明确;装饰器,dunder方法(译注:不知此为何物)等。毫无疑问,这些特性的功能强大,存在这些特性是有原因的。每个特性都是因某人非常关心的事情,尤其是复杂的特性。但是大量使用这些特性使读者很难预测操作的成本。

好消息是,像Go程序员一样,我们可以选择显式代码。显式可能意味着很多事情,也许您可能认为显式只是一种表达官僚主义和漫长风气的好方法,但这只是肤浅的解释。只关注页面的语法、烦恼行长和自制表达式是一种错误的说法。在我看来,更有价值的地方是与耦合和状态有关。

耦合(coupling)是衡量一件东西依赖另一件东西的数量的方法。如果两件事紧密结合,它们就会一起运动。影响其中一个事物的行为会直接反映在另一个事物中。想象一下,一列火车,每个车厢连在一起;发动机行驶到哪里,车厢就跟随到哪里。

描述耦合的另一种方法是内聚(cohesion)一词。内聚衡量两件事自然地在一起的程度。当我们进行一个内聚的争论,或者一个内聚的团队,它们的所有零件都可以自然装配在一起,就像设计的一样。

为什么耦合很重要?因为就像火车一样,当您需要更改一段代码时,与之紧密相关的所有代码都必须更改。一个再适合不过的例子:有人发布了他们的API的新版本,现在您的代码无法通过编译了。

API是不可避免的耦合源,但是存在更多隐蔽的耦合形式。显然,每个人都知道,如果API的原型发生更改,则该调用的传入和返回数据都会发生变化。就在函数原型中;我采用这些类型的值,并返回其他类型的值。但是,如果API以其他方式传递数据怎么办?如果每次调用此API的结果都是基于上次调用该API的结果,即使您没有更改参数该怎么办?

这是状态,状态管理是计算机科学中的问题。

package counter

var count int

func Increment(n int) int {
        count += n
        return count
}

假设我们有这个简单的counter包。您可以调用Increment以增加计数器,即便传入0,你也可以得到返回值。

假设您必须测试此代码,那么每次测试后如何重置计数器?假设您想并行运行这些测试,可以吗?现在,假设您要为每个程序进行不止一个计数,您可以这样做吗?

不,当然不行。显然,答案是将count变量封装为类型。

package counter

type Counter struct {
        count int
}

func (c *Counter) Increment(n int) int {
        c.count += n
        return c.count
}

现在想象一下,这个问题不局限于计数器,还包括应用程序的主要业务逻辑。您可以单独测试吗?您可以并行测试吗?您一次可以使用多个实例吗?如果回答那些问题为否,则原因是软件的包级别状态。

避免包级别状态。通过提供一种类型需要的依赖项作为该类型上的字段,而不是使用包变量,来减少耦合和怪异的行为。

为失败而计划,而不是成功而计划

“Errors should never pass silently.” - The Zen of Python, Item 10
“错误绝不能默默传递。” - Python之禅,条款10

有人说过,支持异常处理的语言遵循武士原则(Samurai principle)。要么全胜归来,要么(失败)全不回来。在基于异常的语言中,函数仅返回有效结果。如果他们没有成功,那么控制流程将采纳完全不同的路径。

未检查的异常显然是不安全的编程模型。当您不知道哪些语句可能引发异常时,如何在存在错误的情况下编写健壮的代码?Java尝试通过引入checked exception的概念来使异常更安全,据我所知,这种checked exception在另一种主流语言中没有被引入。有很多使用异常的语言,但是除了Java,所有语言都使用未经检查的各种异常(unchecked exception)。

显然,Go选择了不同的路径。Go程序员认为,健壮的程序是由处理失败情况的片段组成的,然后再处理happy path。在Go设计的空间中:服务器程序,多线程程序,处理网络输入的程序,如果要构建可靠的程序,那么处理意外数据、超时、连接失败和损坏的数据必须是程序员的首要任务。

“I think that error handling should be explicit, this should be a core value of the language.” - Peter Bourgon, GoTime #91
“我认为错误处理应该是显式的,这应该是语言的一个核心价值观。” - 彼得·布尔贡(Peter Bourgon),GoTime#91

我想回应彼得的主张,因为这是本文的动力。我认为Go的成功很大程度上归功于显式的处理错误的方式。Go程序员首先考虑失败情况。我们首先解决如果...怎么办的情况。这导致程序在编写时处理故障,而不是在生产中处理故障。

反复出现的下面代码片段:

if err != nil {
    return err
}

所付出的成本已基本被在故障发生时刻意处理每个故障情况的价值超过了(译者注:上面的重复代码段也是利大于弊)。关键还在于显式处理每个错误的文化价值观。

早点返回,而不是深层嵌套

“Flat is better than nested.” - The Zen of Python, Item 5
“扁平比嵌套更好。” - Python的禅宗,条款5

这是一个明智的建议,而且它来自以缩进作为控制流主要形式的语言。我们如何用Go来解释这个建议呢?gofmt控制Go程序的整体风格(空白与缩进),因此无需执行任何额外操作。

我之前写过关于package名字的文章,这里可能有一些建议:避免复杂的软件包层次结构。以我的经验,程序员越努力细分和分类Go代码库,他们越有可能陷入包导入循环的死角。

我认为第5项条款建议的最佳应用是函数内的控制流。简而言之,避免需要控制流缩进过深。

“Line of sight is a straight line along which an observer has unobstructed vision.” - May Ryer, "Code: Align the happy path to the left edge" https://medium.com/@matryer/line-of-sight-in-code-186dd7cdea88

“代码行展现给观察者的视觉效果应该是一条畅通的直线。- May Ryer, “代码:将快乐路径对齐到左边缘”

Mat Ryer将这种想法描述为视线编码(line of sight coding )。视线编码意味着:

  • 如果不满足前提条件,则使用保护子句尽早返回。
  • 将成功的return语句放在函数的末尾,而不是放在条件代码块中。
  • 通过提取函数和方法来降低函数的整体缩进级别。

该建议的关键是您所关心的事情,功能所要做的事情永远不会有在屏幕右侧滑出视线的危险。这种风格有一个额外的副作用,您可以避免团队中对行长度的毫无意义的争论。

每次缩进时,都会向程序员堆栈添加另一个先决条件,从而消耗他们的7±2个短期内存插槽之一(译注:7±2指的是人类能短期记忆的事件数量大约是7,±2是个体差异)。将函数的成功执行路径贴近屏幕左手侧,不要深入嵌套。

如果你认为它性能差,请通过基准测试证明

“In the face of ambiguity, refuse the temptation to guess.” - The Zen of Python, Item 12
“面对模棱两可,拒绝猜测的诱惑。” - Python之禅,条款12

编程基于数学和逻辑,这两个概念很少涉及机会元素。但是,作为程序员,我们每天都在猜测许多事情。这个变量有什么作用?此参数有什么作用?如果我在这类传入nil会怎样?如果我调用Register两次会怎样?实际上,现代编程中存在很多猜测,尤其是在使用不是你编写的库时。

“APIs should be easy to use and hard to misuse.”  - Josh Bloch
“API应该易于使用并且不容易被滥用。” - 乔什·布洛赫(Josh Bloch)

我知道的帮助程序员避免猜测的最好方法之一是在构建API时,应专注于默认用例。使调用者尽可能轻松地执行最常见的事情。但是,我过去写过很多关于API设计的文章,所以我对第12项的解释是:不要猜测性能

尽管您可能考虑到Knuth的建议,但Go语言成功的推动力之一是其高性能的执行。您可以在Go中编写高性能的程序,因此人们会因此选择Go。关于性能有很多误解,所以我的要求是,当您希望对代码进行性能调优时,或者遇到一些教条式的建议时,例如defer缓慢,CGO昂贵,或者始终使用原子操作而不是互斥锁时,请不要猜。

不要因为过时的教条而使您的代码复杂化,并且,如果您认为某些事情很慢,请首先使用基准测试进行证明。Go提供了出色的基准测试和性能分析工具,这些工具均可免费获得。使用它们来找出您程序中的性能瓶颈。

在启动goroutine之前,请知道它何时会停止

在这一点上,我认为我已经从PEP-20中挖掘了有价值的要点,并且可能扩展其重新解释的范围。我认为很好,因为尽管这是一种有用的修辞手法,但最终我们还是在谈论两种不同的语言。

“You type go, a space, and then a function call. Three keystrokes, you can’t make it much shorter than that. Three keystrokes and you’ve just started a sub process.” - Rob Pike, Simplicity is Complicated, dotGo 2015

“您键入go,一个空格和一个函数调用。三次按键,您不能做到比这还短了。三次按键,您就启动了一个子过程。” - 罗伯·派克(Rob Pike),Simplicity is Complicated,dotGo,2015年

接下来的两个建议,我将专注于goroutines。Goroutines是语言的标志性功能,这是我们给出的关于一等公民(first class)并发的答案。它们非常易于使用,只需将单词go放在语句前面,即可异步启动该函数。非常简单,没有线程,没有堆栈大小,没有线程池执行程序(thread pool executor),没有ID,没有跟踪完成状态。

Goroutines代价很低。由于运行时(runtime)能够将goroutine多路复用到一个小的线程池中(您不必管理),因此可以轻松容纳数十万,数百万个goroutine。这开创了在竞争性并发模型(例如线程或事件回调)下不可行的设计。

但是,即便如goroutine一样便宜,但它们也不是免费的。至少它们的堆栈有几千字节,当您启动10^6个goroutine时,它们的确开始累加。这并不是说就不应该使用数百万个goroutine,如果你的设计需要,可以做。但是当您这样做时,请务必对其进行跟踪,因为10^6数量级的任何东西累计可能消耗的资源都不是少量的。

Goroutines是Go中资源所有权的关键。为了程序有用,goroutine必须做一些事情,这意味着它几乎总是持有对资源的引用或所有权:锁、网络连接、带有数据的缓冲区、channel的发送端。当该goroutine处于活动状态时,将持有锁,保持网络连接打开,保留缓冲区,并且channel的接收器将继续等待更多数据。

释放这些资源的最简单方法是将它们与goroutine的生命周期相关联-当goroutine退出时,资源释放。因此,尽管开始执行goroutine几乎是微不足道的,但在进行三次按键(go+空格)前,请确保您对以下问题有答案:

  • goroutine在什么情况下会停止? Go没有办法告诉goroutine退出。没有停止或终止功能,这是有充分的理由的。如果我们无法命令goroutine停止,则必须礼貌地对其提出要求。这几乎总是归结于channel操作。当channel关闭时,针对一个channel的range loop将退出循环。如果一个channel关闭,它将变为可选(selectable)。从一个goroutine到另一个goroutine的信号最好表示为一个关闭的channel。

  • 出现这种情况需要什么? 如果channel既是在goroutines之间进行通讯的工具,又是它们传达完成信号的机制,那么程序员面临的下一个问题就是,谁将关闭channel,何时会发生?

  • 您将使用什么信号知道goroutine已停止? 当您发出信号告知goroutine要停止时,在将来的某个时间gouroutine停止动作会发生。就人类的感知而言,它可能很快发生,但是计算机每秒执行数十亿条指令,并且从每个goroutine的角度来看,它们的指令执行是不同步的。解决方案通常是使用channel发应答信号或fan-in方法需要的waitgroup。

将并发留给调用者

在您编写的任何严肃的Go程序中,都可能涉及并发。这就提出了一个问题,我们编写的许多库和代码都采用每个连接一个goroutine或采用工作者(worker)模式。您将如何管理这些goroutine的生命周期?

net/http是一个很好的例子。关闭拥有监听套接字的server相对来说是直截了当的,但是从该接受套接字产生的goroutines呢?net/http确实在请求对象中提供了一个上下文(context)对象,该上下文对象可用于向正在监听的代码发出信号,表明应该取消请求(cancel),从而终止goroutine,但是尚不清楚如何知道何时完成所有这些操作。一种方法是调用context.Cancel,知道取消已经完成是另一回事。2

我想说明的一点net/http是,它是良好实践的反例。由于每个连接都是由net/http.Server类型内部产生的goroutine处理的,因此驻留在程序net/http包外部的程序无法控制接受套接字产生的goroutine。

这是一个仍在不断发展的设计领域,例如go-kitrun.Group和Go团队等努力ErrGroup提供了执行,取消和等待异步运行功能的框架。

这里更大的设计准则是针对库编写者的,或者是任何编写可以异步运行的代码的人,将使用goroutine的责任留给调用者。让调用者选择他们希望如何启动,跟踪和等待函数执行。

编写测试以锁定包API的行为

也许您希望从我这里读到一篇我不咆哮测试的文章。可悲的是,今天不是那天。

测试是关于您的软件做什么和不做什么的契约。程序包级别的单元测试应锁定程序包API的行为。他们用代码描述了程序包承诺要做的事情。如果针对每个输入排列组合都有一个单元测试,那么您已经定义了代码将在代码(而不是文档)中执行的约定 。

通过简单的输入go test,您就可以断言代码是否遵守契约。在任何阶段,您都可以高度自信地知道人们在更改之前所依赖的行为在更改之后将继续有效。

测试会锁定api行为。添加,修改或删除公共api的任何更改都必须包括对其测试的更改。

适度是一种美德

Go是一种简单的语言,只有25个关键字。在某些方面,这使该语言内置的功能脱颖而出。同样,这些是语言销售的功能,轻量级并发,结构化类型。

我想我们所有人都经历过尝试立即使用Go的所有功能所带来的困惑。谁对使用channel如此兴奋以至于他们尽可能多地,尽可能多地使用它们?就我个人而言,我发现结果很难测试,脆弱且最终过于复杂。只有我一个人吗?

我在goroutines上经历了相同的经历,试图将工作分解成很小的单元,我创建了一群难以管理的goroutines,最终观察到我的大多数goroutines总是阻塞等待–代码最终是顺序的,我增加了很多复杂性,几乎没有给现实世界带来任何好处。谁经历过这样的事情?

我在嵌入机制方面(embedding)也有同样的经历。最初,我将其误认为是继承。然后,我通过将已经承担多个职责的复杂类型组合成更复杂的巨大类型重现了创建脆弱的基类问题。

这可能是最不可行的建议,但我认为这一点很重要。建议始终是相同的,所有事情都要适度,Go的特性也不例外。如果可以的话,请不要寻求goroutine或channel,也不要嵌入结构,匿名函数,过渡用package,为每样东西建立接口(interface),要用简单方法而不是聪明的方法。

可维护性很重要

我想谈谈关于PEP-20的最后一项,

“可读性很重要。” - Python之禅,条款7
“Readability Counts.” - The Zen of Python, Item 7

关于可读性的重要性已经被谈论了很多,不仅在Go语言中,而且在所有编程语言中。像我这样的人,倡导在Go的舞台上使用简单,可读性,清晰度,生产力等词,但最终它们都是一个词的同义词- 可维护性

真正的目标是编写可维护的代码。原始作者之后的代码可以存活下了。存在的代码不仅可以作为时间点投资,而且可以作为未来价值的基础。不是可读性并不重要,而是可维护性更重要。

Go并不是为聪明人而优化的语言。Go不是一种为了在程序中编写最少行数而进行优化的语言。我们没有针对磁盘上源代码的大小进行优化,也没有针对将程序键入编辑器花费的时间进行优化。而是,我们希望优化我们的代码以使读者清晰(clear)。因为需要维护此代码的人正是读者。

如果您是为自己编写程序,则也许只需要运行一次,或者您是唯一会看到该程序的人,然后程序为您工作。但是,如果这是一个将由多个人贡献的软件,或者将由人们使用足够长的时间以致其需求,功能或运行环境可能发生变化,那么您的目标必须是针对程序的可维护性。如果无法维护软件,则它将被重写;那可能是您的公司最后一次投资Go。

你离开后,您努力实现东西可以维护吗?您今天该如何做才能使某人明天更容易维护您的代码?



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

我爱发短信:企业级短信平台定制开发专家 https://51smspush.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

微信赞赏:
img{512x368}

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


  1. 演讲的这一部分具有Ruby,Swift,Elm,Go,NodeJS,Python,Rust的网站登录页面的几个屏幕截图,展示了该语言如何描述自己。 

  2. 我倾向于选择net/http很多东西,但这并不是因为它很糟糕,实际上是相反的,它是Go代码库中最成功,最古老,最常用的API。因此,它的设计,发展和缺点已被彻底地接受。你可以认为这是奉承,而不是批评。 

图解Go内存分配器

本文翻译自《A visual guide to Go Memory Allocator from scratch (Golang)》

当我刚开始尝试了解Go的内存分配器时,我发现这真是一件可以令人发疯的事情,因为所有事情似乎都像一个神秘的黑盒(让我无从下手)。由于几乎所有技术魔法都隐藏在抽象之下,因此您需要逐一剥离这些抽象层才能理解它们。

在这篇文章中,我们就来这么做(剥离抽象层去了解隐藏在其下面的技术魔法)。如果您想了解有关Go内存分配器的知识,那么本篇文章正适合您。

一. 物理内存(Physical Memory)和虚拟内存(Virtual Memory)

每个内存分配器都需要使用由底层操作系统管理的虚拟内存空间(Virtual Memory Space)。让我们看看它是如何工作的吧。

img{512x368}

物理存储单元的简单图示(不精确的表示)

单个存储单元(工作流程)的简要介绍:

  1. 地址线(address line, 作为开关的晶体管)提供了访问电容器的入口(数据到数据线(data line))。
  2. 当地址线中有电流流动时(显示为红色),数据线可能会写入电容器,因此电容器已充电,并且存储的逻辑值为“1”。
  3. 当地址线没有电流流动(显示为绿色)时,数据线可能不会写入电容器,因此电容器未充电,并且存储的逻辑值为“0”。
  4. 当处理器(CPU)需要从内存(RAM)中“读取”一个值时,会沿着“地址线”发送电流(关闭开关)。如果电容器保持电荷,则电流流经“ DATA LINE”(数据线)得到的值为1;否则,没有电流流过数据线,电容器将保持未充电状态,得到的值为0。

img{512x368}

物理内存单元如何与CPU交互的简单说明

数据总线(Data Bus):用于在CPU和物理内存之间传输数据。

让我们讨论一下地址线(Address Line)和可寻址字节(Addressable Bytes)。

img{512x368}

CPU和物理内存之间的地址线的表示

  1. DRAM中的每个“字节(BYTE)”都被分配有唯一的数字标识符(地址)。 但“物理字节的表示 != 地址线的数量”。(例如:16位Intel 8088,PAE)
  2. 每条“地址线”都可以发送1bit值,因此它可以表示给定字节地址中指定“bit”。
  3. 在图中,我们有32条地址线。因此,每个可寻址字节都将拥有一个“32bit”的地址。
[ 00000000000000000000000000000000 ] — 低内存地址
[ 11111111111111111111111111111111 ] — 高内存地址

4.由于每个字节都有一个32bit地址,所以我们的地址空间由2的32次方个可寻址字节(即4GB)组成。

因此,可寻址字节取决于地址线的总量,对于64位地址线(x86–64 CPU),其可寻址字节为2的64次方个,但是大多数使用64位指针的体系结构实际上使用48位地址线(AMD64 )和42位地址线(英特尔),理论上支持256TB的物理RAM(Linux 在x86–64上每个进程支持128TB以及4级页表(page table)和Windows每个进程则支持192TB)

由于实际物理内存的限制,因此每个进程都在其自己的内存沙箱中运行-“虚拟地址空间”,即虚拟内存

该虚拟地址空间中字节的地址不再与处理器在地址总线上放置的地址相同。因此,必须建立转换数据结构和系统,以将虚拟地址空间中的字节映射到物理内存地址上的字节。

虚拟地址长什么样呢?

img{512x368}

虚拟地址空间表示

因此,当CPU执行引用内存地址的指令时。第一步是将VMA(virtual memory address)中的逻辑地址转换为线性地址(liner address)。这个翻译工作由内存管理单元MMU(Memory Management Unit)完成。

img{512x368}

这不是物理图,仅是描述。为了简化,不包括地址翻译过程

由于此逻辑地址太大而无法单独管理(取决于各种因素),因此将通过页(page)对其进行管理。当必要的分页构造被激活后,虚拟内存空间将被划分为称为页的较小区域(大多数OS上页大小为4KB,可以更改)。它是虚拟内存中用于内存管理的最小单位。虚拟内存不存储任何内容,仅简单地将程序的地址空间映射到真实的物理内存空间上。

单个进程仅将VMA(虚拟内存地址)视为其地址。这样,当我们的程序请求更多“堆内存(heap memory)”时会发生什么呢?

img{512x368}

一段简单的用户请求更多堆内存的汇编代码

img{512x368}

增加堆内存

程序通过brk(sbrk/mmap等)系统调用请求更多内存。但内核实际上仅是更新了堆的VMA。

注意:此时,实际上并没有分配任何页帧,并且新页面也没有在物理内存存在。这也是VSZ与RSS之间的差异点。

二. 内存分配器

有了“虚拟地址空间”的基本概述以及堆内存增加的理解之后,内存分配器现在变得更容易说明了。

如果堆中有足够的空间来满足我们代码中的内存请求,则内存分配器可以在内核不参与的情况下满足该请求,否则它会通过系统调用brk扩大堆,通常会请求大量内存。(默认情况下,对于malloc而言,大量的意思是 > MMAP_THRESHOLD字节-128kB)。

但是,内存分配器的责任不仅仅是更新brk地址。其中一个主要的工作则是如何的降低内外部的内存碎片以及如何快速分配内存块。考虑按p1~p4的顺序,先使用函数malloc在程序中请求连续内存块,然后使用函数free(pointer)释放内存。

img{512x368}

外部内存碎片演示

在第4步,即使我们有足够的内存块,我们也无法满足对6个连续内存块分配的请求,从而导致内存碎片。

那么如何减少内存碎片呢?这个问题的答案取决于底层库使用的特定的内存分配算法。

我们将研究TCMalloc内存分配器,Go内存分配器采用的就是该内存分配器模型。

三. TCMalloc

TCMalloc(thread cache malloc)的核心思想是将内存划分为多个级别,以减少锁的粒度。在TCMalloc内部,内存管理分为两部分:线程内存和页堆(page heap)。

线程内存(thread memory)

每个内存页分为多级固定大小的“空闲列表”,这有助于减少碎片。因此,每个线程都会有一个无锁的小对象缓存,这使得在并行程序下分配小对象(<= 32k)非常高效。

img{512x368}

线程缓存(每个线程拥有此线程本地线程缓存)

页堆(page heap)

TCMalloc管理的堆由页集合组成,其中一组连续页的集合可以用span表示。当分配的对象大于32K时,将使用页堆进行分配。

img{512x368}

页堆(用于span管理)

如果没有足够的内存来分配小对象,内存分配器就会转到页堆以获取内存。如果还没有足够的内存,页堆将从操作系统中请求更多内存。

由于这种分配模型维护了一个用户空间的内存池,因此极大地提高了内存分配和释放的效率。

注意:尽管go内存分配器最初是基于tcmalloc的,但是现在已经有了很大的不同。

四. Go内存分配器

我们知道Go运行时会将Goroutines(G)调度到逻辑处理器(P)上执行。同样,基于TCMalloc模型的Go还将内存页分为67个不同大小级别。

如果您不熟悉Go调度程序,则可以在这里获取关于Go调度程序的相关知识。

img{512x368}

Go中的内存块的大小级别

Go默认采用8192B大小的页。如果这个页被分成大小为1KB的块,我们一共将拿到8块这样的页:

img{512x368}

将8 KB页面划分为1KB的大小等级(在Go中,页的粒度保持为8KB)

Go中的这些页面运行也通过称为mspan的结构进行管理。

选择要分配给每个尺寸级别的尺寸类别和页面计数(将页面数分成给定尺寸的对象),以便将分配请求圆整(四舍五入)到下一个尺寸级别最多浪费12.5%

mspan

简而言之,它是一个双向链表对象,其中包含页面的起始地址,它具有的页面的span类以及它包含的页面数。

img{512x368}

Go内存分配器中mspan的表示形式

mcache

与TCMalloc一样,Go为每个逻辑处理器(P)提供了一个称为mcache的本地内存线程缓存,因此,如果Goroutine需要内存,它可以直接从mcache中获取它而无需任何锁,因为在任何时间点只有一个Goroutine在逻辑处理器(P)上运行。

mcache包含所有级别大小的mspan作为缓存。

img{512x368}

Go中P,mcache和mspan之间的关系

由于每个P拥有一个mcache,因此从mcache进行分配时无需加锁。

对于每个级别,都有两种类型。
* scan —包含指针的对象。
* noscan —不包含指针的对象。

这种方法的好处之一是在进行垃圾收集时,GC无需遍历noscan对象。

什么Go mcache?

对象大小<= 32K字节的分配将直接交给mcache,后者将使用对应大小级别的mspan应对

当mcache没有可用插槽(slot)时会发生什么?

从mcentral mspan list中获取一个对应大小级别的新的mspan。

mcentral

mcentral对象集合了所有给定大小级别的span,每个mcentral是两个mspan列表。

  1. 空的mspanList — 没有空闲内存的mspan或缓存在mcache中的mspan的列表
  2. 非空mspanList – 仍有空闲内存的span列表。

当从mcentral请求新的Span时,它将从非空mspanList列表中获取(如果可用)。这两个列表之间的关系如下:当请求新的span时,该请求从非空列表中得到满足,并且该span被放入空列表中。释放span后,将根据span中空闲对象的数量将其放回非空列表。

img{512x368}

mcentral表示

每个mcentral结构都在mheap中维护。

mheap

mheap是在Go中管理堆的对象,且只有一个全局mheap对象。它拥有虚拟地址空间。

img{512x368}

mheap的表示

从上图可以看出,mheap具有一个mcentral数组。此数组包含每个大小级别span的mcentral。

central [numSpanClasses]struct {
      mcentral mcentral
        pad      [sys.CacheLineSize unsafe.Sizeof(mcentral{})%sys.CacheLineSize]byte
}

由于我们对每个级别的span都有mcentral,因此当mcache从mcentral请求一个mspan时,仅涉及单个mcentral级别的锁,因此其他mache的不同级别mspan的请求也可以同时被处理。

padding确保将MCentrals以CacheLineSize字节间隔开,以便每个MCentral.lock获得自己的缓存行,以避免错误的共享问题。

那么,当该mcentral列表为空时会发生什么?mcentral将从mheap获取页以用于所需大小级别span的分配。

  • free [_MaxMHeapList]mSpanList:这是一个spanList数组。每个spanList中的mspan由1〜127(_MaxMHeapList-1)页组成。例如,free[3]是包含3个页面的mspan的链接列表。Free表示空闲列表,即尚未进行对象分配。它对应于忙碌列表(busy list)。

  • freelarge mSpanList:mspans列表。每个mspan的页数大于127。Go内存分配器以mtreap数据结构来维护它。对应busyLarge。

大小> 32k的对象是一个大对象,直接从mheap分配。这些较大的请求需要中央锁(central lock),因此在任何给定的时间点只能满足一个P的请求

五. 对象分配流程

  • 大小> 32k是一个大对象,直接从mheap分配。
  • 大小<16B,使用mcache的tiny分配器分配
  • 大小在16B〜32k之间,计算要使用的sizeClass,然后在mcache中使用相应的sizeClass的块分配
  • 如果与mcache对应的sizeClass没有可用的块,则向mcentral发起请求。
  • 如果mcentral也没有可用的块,则向mheap请求。mheap使用BestFit查找最合适的mspan。如果超出了申请的大小,则会根据需要进行划分,以返回用户所需的页面数。其余页面构成一个新的mspan,并返回mheap空闲列表。
  • 如果mheap没有可用的span,请向操作系统申请一组新的页(至少1MB)。

但是Go在OS级别分配的页面甚至更大(称为arena)。分配大量页面将分摊与操作系统进行对话的成本。

所有请求的堆内存都来自于arena。让我们看看arena是什么。

六. Go虚拟内存

让我们看一个简单go程序的内存。

func main(){
    for {}
}

img{512x368}

程序的进程状态

因此,即使是简单的go程序,占用的虚拟空间也是大约100MB而RSS只有696kB。让我们尝试首先找出这种差异的原因。

img{512x368}

map和smap统计信息

因此,内存区域的大小约为〜2MB, 64MB and 32MB。这些是什么?

Arena

原来,Go中的虚拟内存布局由一组arena组成。初始堆映射是一个arena,即64MB(基于go 1.11.5)。

img{512x368}

当前在不同系统上的arena大小。

因此,当前根据程序需要,内存以较小的增量进行映射,并且它以一个arena(〜64MB)开始。

这是可变的。早期的go保留连续的虚拟地址,在64位系统上,arena大小为512 GB。(如果分配足够大并且被mmap拒绝,会发生什么?)

这个arena集合是我们所谓的堆。Go以8192B大小粒度的页面管理每个arena。

img{512x368}

单个arena(64 MB)。

Go还有两个span和bitmap块。它们都在堆外分配,并存储着每个arena的元数据。它主要在垃圾收集期间使用(因此我们现在将其保留)。

我们刚刚讨论过的Go中的内存分配策略,但这些也仅是奇妙多样的内存分配的一些皮毛。

但是,Go内存管理的总体思路是使用不同的内存结构为不同大小的对象使用不同的缓存级别内存来分配内存。将从操作系统接收的单个连续地址块分割为多级缓存以减少锁的使用,从而提高内存分配效率,然后根据指定的大小分配内存分配,从而减少内存碎片,并在内存释放houhou有利于更快的GC。

现在,我将向您提供此Go Memory Allocator的全景图。

img{512x368}

运行时内存分配器的可视化全景图。


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

我爱发短信:企业级短信平台定制开发专家 https://51smspush.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

微信赞赏:
img{512x368}

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! 图片广告位1 图片广告位2 图片广告位3 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats