2023年六月月 发布的文章

Go语言包设计指南

本文永久链接 – https://tonybai.com/2023/06/18/go-package-design-guide

1. Go包的认知

1.1 Go包是基本功能单元

我们知道Go包是Go编程语言中的一个重要概念,它是一组相关的Go源代码文件。并且,在Go中,每个Go源文件都必须属于一个包。

Go包是一个逻辑上独立的单元,是Go的基本功能单元,用来做功能边界的划分。这些基本功能单元的累加就构成了Go应用,因此Go应用的本质就是一组Go包的集合。

Go包这种功能独立的单元为Go开发者提供了“封装”和复用的便利。在Go中,Go包也是代码复用的基本单元,被用来管理和组织代码,Go项目的结构布局本质上就是安排Go包的位置,使得代码更易于维护和重用。

1.2 Go包是基本编译单元

Go包还是编译时的最小单位。也就是说,Go编译器编译代码时会以包为单位进行编译,而不是以文件为单位。这意味着一个包中的所有源文件都将被编译成一个单独的目标文件,而不是多个目标文件。

使用包而不是文件作为编译单元,有助于提高编译效率和管理依赖关系。

注:编译速度快是包这种设计“先进性”的一个表现,即便每次编译都是从零开始。Go编译速度快的几个原因与以包作为编译单元是密不可分的,具体体现在Go源文件在开头处显式地列出所有依赖包,编译器不必读取整个文件就可确定依赖包列表;Go包之间不能存在循环依赖,由于无环,包可以被单独编译,也可以并行编译;已编译的Go包的目标文件中记录了其所依赖包的导出符号信息。Go编译器在读取该目标文件时不需进一步读取其依赖包的目标文件。

1.3 Go包是基本设计单元

这个世界越来越复杂,软件系统同样变得日益复杂。无论你是什么编程语言的开发者,我们要面对的都是如何驯服这种复杂性。到目前为止,我们驯服这种复杂性的思路还很初级,无非是对复杂性进行分解、分解、分解,并按照我们更容易理解的方式重新组合

Go包是基本功能单元,对于Go开发者,我们要将复杂性分解为一个个包,然后以一种合理的方式将包组合在一起以实现我们要的系统,因此Go包也是我们面对一个系统时的基本设计单元。我们不仅要设计每个包肩负的职责,还要设计包与包之间的关系。

因此,Go系统设计就是面向包进行设计。

接下来,我们就来看看Go包的设计思路。

2. Go包设计思路

即便你没写过Go程序,作为程序员你也应该知道“高内聚,低耦合”这个原则在软件系统设计中的分量。这里我们就以这个原则作为“抓手”来展开看看Go包的设计思路。

高内聚, 低耦合这个顶层原则,适用于所有编程语言的系统设计。但落到Go包设计上面,具体如何体现高内聚与低耦合呢?我们继续往下看。

2.1 功能选桶:自然内聚

面对一个复杂系统,我们通常会做一些系统分析,比如用领域驱动设计的方式从需求中挖掘出一堆术语、事件、命令等(即便你不懂领域设计的纯正方法,你的实际操作过程也或多或少与领域设计的内容重叠)。之后,通常会分层、划分服务,每个服务又要划分模块或包。

在服务这一层次上哪些功能放到哪个包里呢?这个过程我称之为“功能选桶”。

这让我想到了和孩子一起学习动物分类时的书中题目:

有这样一组动物:老虎、狮子、海马、大雁、熊猫、黄鹂、鲸鱼,这些动物能分为哪几个类别呢?

一个稍稍被启蒙了的孩子都会给出这样的分类:

陆地动物:老虎、狮子、熊猫
海洋动物:海马、鲸鱼
天空动物:大雁、黄鹂

而另外一个稍有一些生物学入门知识的大点的孩子可能也会给出下面的分类:

哺乳动物:老虎、狮子、熊猫、鲸鱼
卵生动物:海马、大雁、黄鹂

无论哪种,这些分类都是基于动物行为特征的自然结合。第一种似乎更直观自然,第二种则需要有更“专业”的知识(领域知识)。Go包的“功能选桶”其实是一个道理,相关功能自然结合到一个包中,保证这个包的内聚性。

比如下面有几个功能函数:Add、Subtract、Multiply、Divide、Sum、Average、Histogram,我们如何为这几个函数选桶呢?

一种不那么内聚的作法是将上述所有函数都放入math包;而更自然内聚一些的作法则是将Add、Subtract、Multiply、Divide放入math包,而将Sum、Average、Histogram等放入stats包(statistics,统计学)。

在功能选桶过程中,越符合常人思维,就越自然,可读性和可理解性大概率就越好。

2.2 包间关系:最小耦合

功能选桶之后,我们再来看包与包之间的关系,通常我们这种关系称为耦合。

用白话来理解耦合就是:当a变化时,b受到影响并随之变化,则说b与a之间存在耦合,即b依赖a。a是引发b变化的一个原因。

程序员都知道:一种理想的耦合情况是正交,即你变你自变,我岿然不动。但现实中这很难达到,我们应该追求的是尽可能地降低包与包间的耦合

在包依赖层面,Go强制要求不能存在循环依赖,即Go包之间的耦合一定是有向无环的,这一定层度上也能帮助Go包之间降低耦合。

要降低包与包之间的耦合,我们首先要了解Go包间的最低耦合关系是什么呢?

在代码层面最低的耦合是接口耦合,在Go中,接口的实现是隐式的,即a包实现b包中定义的接口时是不需要显式导入b包的,我们可以在c包中完成对a包与b包的组装,这样c包依赖a包和b包,但a包与b包之间没有任何耦合。

那么负责组装a包与b包的c包能否在代码层面消除掉对a和b的依赖呢?这个就很难了。不过我们可以使用依赖注入技术来消除在代码层面手动基于依赖进行初始化或创建时的复杂性,不过依赖注入技术也是有“门槛”的,它会让你的代码不那么straightforward,代码的可读性和可理解性会下降。

注:个人觉得:依赖注入在Go中并非是一种惯用法。Google开源了像wire这样的依赖注入框架(通过代码生成而实现的编译期依赖注入),更多是为了解决掉内部大型Go项目初始化时各种创建动作的复杂性。

我们可以参考软件界用于降低代码耦合的原则,比如由Robert C. Martin(通常被称为“Uncle Bob”)在《敏捷软件开发》一书中提出的旨在帮助开发人员设计更加灵活、可扩展和可维护的软件系统的SOLID敏捷设计原则,这些原则如何应用在Go上呢,或者在Go中如何体现呢,我们接下来就来看一下。

注:“敏捷设计是一个过程,而不是一次事件。它是一个持续应用原则、模式以及实践来改进软件结构和可读性的过程。它致力于保持系统的设计在任何时间都尽可能的简单、整洁和富有表现力。” – 《敏捷软件开发》

2.3 应用SOLID设计原则

2.3.1 单一职责原则(SRP)

对于一个类而言,应该仅有一个原因会引起它的变化。在SRP的语境中,我们把职责定义为“变化的原因”(a reason for change)。如果你有超过一个的动机去改变一个类,那么这个类就具有多种职责。- 《敏捷软件开发》

就像Uncle Bob在书中说的那样:“如果你有超过一个的动机去改变一个类,那么这个类就具有多种职责。有时,我们很难注意到这一点。我们习惯于以组(group)的形式去考虑职责”。

在Go包这一层次上,SRP更多体现在功能内聚上,就像前面举的math包和stats包的例子。

再比如我们有一个图形库,它可以绘制不同类型的图形,如矩形、圆形、三角形等。我们可能会定义一个graph包,里面定义了Graphics类型,它具有Draw方法,用于绘制图形。在不遵循SRP的情况下,graph包Graphics类型可能会包含绘制各种类型图形的代码,这会导致类不仅包含多个职责,而且功能不够内聚。

在遵循SRP的情况下,我们可以在graph包中定义Graphics接口,该接口具有Draw方法,然后在rectangle、circle、triangle包中分别定义Graphics接口的实现:Rectangle类型、Circle类型与Triangle类型:

graph/
    - graph.go // 定义Graphics接口
    - rectangle/
        - rectangle.go // 定义Rectangle类型和其Draw方法
    - circle/
        - circle.go // 定义Circle类型和其Draw方法
    - triangle/
        - triangle.go // 定义Triangle类型和其Draw方法

这样,每个包都只负责一个图形类型,职责更加单一,也更容易维护和扩展。

2.3.2 开放-关闭原则(OCP)

软件实体(类、模块、方法等)应该对扩展开放,但是对修改关闭。- 《敏捷软件开发》

还以上面的graph等包为例,OCP原则可以体现在两方面:

  • 扩展Graphics接口的实现

我们无法修改graph.go中的Graphics接口,但如果你要添加一个square包,定义Square类型并实现Draw方法,那么我们可以在graph包下面添加一个square包,这个包和circle等包位于同等位置,都实现了graph包的Draw方法。

  • 基于Graphics接口的组合

我们无法修改graph.go中的Graphics接口,但是我们可以基于graph.Graphics接口去组合出其他具有更多职责的接口或非接口类型,就像io包中的Reader、Writer接口被组合到ReaderCloser、ReadWriteCloser中一样。

OCP原则的关键是抽象,在Go中建立包与包之间关系抽象的最佳方法就是建立接口类型。前面说过,通过接口的耦合是最低的包间耦合,因此采用OCP原则对于降低包间耦合具有重要意义。

不过,Bob大叔在书中也说了:“遵循OCP的代价也是昂贵的。创建恰当的抽象是要花费时间和精力的。那些抽象也增加了软件设计的复杂性,开发人员有能力处理的抽象数量是有限的”。OCP原则的应用应该被限定在最可能发生的变化上。

2.3.3 里氏替换原则(LSP)

对于里氏替换原则(LSP),可以如此解释:子类型(subtype)必须能够替换掉它们的基类(base type)。- 《敏捷软件开发》

Bob大叔在讲解LSP原则时使用的语言是C++和Java,对于这两种静态类型的OO语言来说,支持抽象和多态的关键机制之一是继承(inheritance)。也只有在继承的概念之上,采用基类和子类之分。

不过Go并非传统意义上的OO语言,它没有继承,没有类型层次体系。即便没有这些,Go也不乏抽象表达能力,最直接的就是接口这个行为的集合。

这样里氏替换原则(LSP)在Go中就可以如此解释:接口I的所有实现都是可以相互替代的,因为它们履行了同样的契约

2.3.4 接口隔离原则(ISP)

客户端程序不应该被迫依赖于它们不需要的方法。- 《敏捷软件开发》

这个在体现Go包与包关系层面不是那么明显,方法已经告诉你这种耦合是接口耦合,但究竟用的是什么样的接口呢?“胖接口”,不是!我们需要刚刚好,不多不少的接口。

来看一个例子:我们有如下一些接口定义:

type Printer interface {
    Print()
}

type Scanner interface {
    Scan()
}

type PrintSleeper interface {
    Printer
    Sleep()
}

type PrintScanSleeper interface {
    Printer
    Scanner
    Sleep()
}

现在我们要实现一个打印机打印的API,我们最初的设计是:

func Print(p PrintScanSleeper, data []byte) error {
}

在这个设计中,Print函数依赖的是PrintScanSleeper,这意味着传入的合法参数的类型必须要实现Print、Scan和Sleep三个方法,但我们的函数只是为了实现打印,它不需要调用Scanner的Scan方法,根据ISP原则,我们不应该强迫Print函数依赖它们本不需要的方法,于是第二版设计如下:

func Print(p Printer, data []byte) error {
}

这似乎无懈可击。但常识告诉我们,每次打印结束后,都需要让打印机休眠,那么显然仅依赖Printer接口又缺少了点东西,那么最终版的设计如下:

func Print(p PrintSleeper, data []byte) error {
}

对ISP原则的白话阐述就是:“不多不少,刚刚好”!

2.3.5 依赖倒置原则(DIP)

高层次的模块不应该依赖低层次的模块。两者都应该依赖抽象。抽象不应该依赖于细节,细节应该依赖于抽象。- 《敏捷软件开发》

如果你的代码符合上面的几条原则的话,那么到这里,你的代码很大可能也是符合DIP原则的。

一提到“依赖抽象”,大家肯定想到的还是接口。在Go中,接口是抽象的主要代名词。

在包与包的关系层面上,DIP原则表现为:高层次包依赖接口,低层次的包实现接口,如下图:

因此,在同等条件下,采用DIP原则设计良好的Go程序的包导入图应该是宽而平的,而不是高而窄的:

3. 单包设计

说完了包的内聚与包间关系的耦合后,我们最后将精力聚焦在单包的设计上面,看看一个Go包在设计方面有哪些值得借鉴的tips。

3.1 包名

我们在引用某个包的导出标识符时使用的是:

pkgname.XXX

由此可见包名的重要性,它可以理解为一个包的API的重要组成部分,因此包设计的第一步就是要为包起个好名字

给Go包起名字首先要注意简单达意,比如标准库的fmt、io、os等,并且包名按惯例应该与其目录名一致;

其次,同一工程内部包名最好是唯一的,避免工程内部出现名字碰撞

最后,如果为了简洁而失去了包名的内聚性的内涵(功能和作用),比如utils、common这些名字基本无法表达包究竟担负的职责,那么莫不如将包名加长一些,点缀上能达意的单词,比如printutil而不仅仅是util。

3.2 最小暴露表面积

在单包设计时,要考虑最小暴露表面积,指定是应该尽可能减少包暴露给外部的接口和实现,只暴露必要的最小接口,以提高代码的安全性和可维护性。同时,从用户角度来看,只暴露必要信息的包看起来更易用。

具体来说,可以分为如下几点:

  • 使用接口建立抽象

在设计包时,应该使用接口来建立抽象,而不是直接暴露实现。这样可以将实现细节隐藏起来,只暴露接口,从而提高代码的安全性和稳定性。

  • 最小化暴露的接口

即便是暴露接口,在设计包时,也应该尽量减少暴露给外部的接口数量。只有必要的接口应该暴露出来,从而提高代码的安全性和稳定性。

  • 使用非导出方法和变量封装实现细节

在设计包时,应该使用非导出方法和变量来封装包内部的实现细节,只暴露公共接口。这样可以将实现细节隐藏起来,避免外部代码直接依赖包内部的实现,从而提高代码的可维护性和灵活性。

  • 最小化暴露的实现

在设计包时,应该尽量减少暴露给外部的实现数量。只有必要的实现应该暴露出来,而不是将所有实现都暴露出去。这样可以避免外部代码直接依赖包内部的实现,从而提高代码的可维护性和灵活性。

3.3 避免包级变量带来的包级状态

Go没有显式的全局变量,但包的导出变量本质上就是全局变量。在《聊聊Go语言的全局变量》一文中我们详细说明了全局变量的不足,因此应避免这类充当全局变量的包级变量的暴露。

3.4 main包应尽可能简洁

在Go中,main包是特殊的包,用于定义程序的入口函数main。在Go中,main函数应该尽可能简洁,它应该只负责装配其他包,调用其他函数或模块,不应该包含过多的代码逻辑。这样可以提高代码的可读性和可维护性。如果要对main函数进行单测的话,那么可以将main函数的逻辑放置到另外一个函数中,比如run,然后对run函数进行详尽的测试。

3.5 接口类型定义应放在与使用者更近的地方

Go接口是隐式实现的,意味着其实现者不需要显式告知实现了该接口,实现者所在包也无需导入接口定义所在的包。

这样一来,将接口类型定义放在与使用者更近的地方,可以使代码更加清晰和易于理解。使用者可以直接看到接口类型定义,了解接口类型的作用和使用方法。但注意:这并非是绝对的规则。

有些接口的实现者喜欢在自己的包中放置var i some_interface = (*T)(nil) ,以利用编译器的静态检查断言自己定义的类型*T实现了接口some_interface,这样一来实际上是显式宣告了在实现者和接口包之间关系,属于“增加耦合”的步骤。

如果接口类型在同一个包里提供了默认实现,那么这么做无可厚非,比如io包。

4. 小结

下面对本文内容做个小结:

  • Go包是Go程序设计的基本单元,分解复杂性的基本单位。
  • Go包应被设计为高内聚,关注同一职责,并尽量与其他包低耦合。
  • 在设计Go包时,可以按照功能选桶,根据自然内聚思维来划分包,并遵循最小耦合原则减少包间依赖。
  • 可以运用SOLID设计原则优化Go包间的关系:
    • SRP:每个包都有单一的职责,具有高内聚。
    • OCP:包对扩展开放,对修改关闭。
    • LSP:接口的实现是互相替换的。
    • ISP:接口将只暴露必要方法。
    • DIP:高层包和低层包都依赖抽象,细节应依赖抽象。
  • 在单包设计时应考虑最小暴露表面积,只暴露必要的接口和实现。
  • 避免用包级变量带来的全局状态。main包应简洁。
  • 接口类型定义最好放在使用者更近的地方。

希望能为大家提供参考!如果有不正确或遗漏的地方,欢迎指出,共同进步。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商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
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

Go GC:了解便利背后的开销

本文永久链接 – https://tonybai.com/2023/06/13/understand-go-gc-overhead-behind-the-convenience

注:本文部分摘录自GopherChina 2023前的《Go高级工程师训练营》课程。

1. 简介

当今,移动互联网和人工智能的快(越)速(来)发(越)展(卷),对编程语言的高效性和便利性提出了更高的要求。Go作为一门高效、简洁、易于学习的编程语言,受到了越来越多开发者的青睐。

Go语言的垃圾回收机制(Garbage Collection,简称 GC)是其重要的运行机制之一,它可以帮助开发人员避免手动管理内存的复杂性和错误,为开发者带来开发上的便利,使开发者可以更专注于业务逻辑的实现。然而,GC的便利性背后也带来了一定的系统开销,作为成熟的Go开发者,我们需要了解GC带来的开销和优化方法,以帮助我们更好的了解和使用Go语言。

了解Go GC的原理是了解GC开销的前提条件,我们首先来简要看看Go GC的原理。

2. Go GC的简明原理

Go语言的垃圾回收器采用了并发三色标记清除算法(Concurrent Tri-Color Mark-And-Sweep),尽可能减少STW(stop the world)时间,以降低吞吐为代价换取低延迟,实现了高效的垃圾回收。

标记清除算法的基本原理是,垃圾回收器将所有的存活对象标记为“活”的,未被标记的对象则被认为是垃圾。经典的标记清除算法通常分为两个阶段:

  • 标记阶段:垃圾回收器从根对象开始,遍历所有可达对象,并将它们标记为“活”的。
  • 清除阶段:垃圾回收器从堆的起始地址开始遍历,将未被标记的对象清除,回收内存。

Go语言的垃圾回收器采用了三色标记法(Tri-Color Marking),将堆上的内存对象分为三种颜色:

  • 白色:未被标记为“活”的对象,是潜在的垃圾,后续可能会被GC回收。
  • 灰色:待扫描的对象,当扫描某个灰色对象时,GC会将其标记为黑色,然后将该对象指向的所有对象都标记为灰色,待后续标记。
  • 黑色:被标记为“活”的对象,在这轮GC中不会被回收。

垃圾回收器开始工作时不存在黑色对象,垃圾回收器会将根对象标记为灰色,并从根对象(通常是栈对象和全局对象)开始遍历。垃圾回收器会将灰色对象标记为黑色,并将该对象指向的对象标记为灰色。垃圾回收器重复这个过程,直到所有可达对象都被标记为黑色。最后,垃圾回收器清除所有未被标记为黑色的对象,即清除所有白色对象。

前面提到过,Go语言的GC采用了并发标记的技术,以减少GC对系统性能的影响。并发标记指的是在GC运行时程序仍然可以继续运行,而不必停止程序的执行。为了避免程序修改对象时对标记的影响,GC会利用混合写屏障技术,在对象被修改时进行特殊标记(若程序修改黑色对象(已被扫描完毕,不会再扫描),使之指向白色对象时,写屏障技术会将白色对象标记为灰色,避免白色对象被释放导致黑色对象出现悬挂指针的情况)。写屏障技术可以有效避免并发标记阶段的错误标记,但也会带来一定的性能开销

3. GC的开销

从上面的Go GC原理来看,GC在带来便利的同时,开销是不可避免的。

3.1 GC开销的主要来源

GC开销的主要来源包括以下几个:

  • STW时间

Go诞生初期,GC的实现不是很成熟,STW时间很长,这让很对想使用Go在生产上作为一番的开发人员打了“退堂鼓”。Go 1.5版本自举后,GC的STW时间大幅下降,又经过几个版本的打磨后,STW时间已经被Go降低到很短了,通常情况下都在1毫秒以内,甚至可以到几十微秒,STW时间的大幅缩短让Go真正走进了生产环境。

不过再短的STW对于程序执行来说也是开销,因为STW期间,所有属于业务逻辑的代码都无法向前推进(make progress)。

那么一个GC周期究竟会做几次STW呢?这里借用“Go语言原本”中的一个表格:

这个表格描述了Go垃圾回收器主要包含的五个阶段,我们看到虽然采用了并发三色标记和清除,但在一次GC周期内,还是要有2次STW,一次是结束标记,关闭写屏障,另一次是为下一个周期的并发标记做准备,开启写屏障。

STW时间依然是GC开销的主要来源之一。减少STW时间对于优化GC的性能依然至关重要,尤其是任意场景下都要保证尽可能短暂的STW,但这是Go core团队的任务。

  • 标记与清除阶段的负荷

在标记与清除阶段,GC需要遍历堆内存中的所有对象,并进行标记和清除,这也是十分消耗cpu的工作。

  • 标记辅助

GC的并发标记并非只是由特定(dedicated) goroutine去完成的,为了保证GC标记清扫的速度不低于业务goroutine分配内存的速度,保证程序不因消耗内存过快过大而被OS OOM(Out Of Memory) Killed,GC引入标记辅助技术,即让每个业务goroutine都有机会参与到GC标记工作中来!并且,这种标记辅助采用的是一种补偿机制,即该业务goroutine分配的内存越多,它要辅助标记的内存就越多。一旦某个业务goroutine被“拉壮丁”执行标记辅助工作,那么该goroutine的业务执行就会暂停,业务逻辑也就无法向前推进。

  • 堆内存的释放

当Go GC回收了堆内存之后,如果堆的大小变得比之前小了,那么垃圾回收器会向操作系统归还多余的内存空间。在Linux等操作系统中,操作系统会将这些内存页标记为“未使用”,但是这些内存页并不会立即返回给操作系统,而是留给程序使用,以便程序将来再次申请内存时可以直接使用已经分配的内存页,从而减少内存分配的时间和开销。当程序没有使用这些内存页一段时间后,操作系统会将这些内存页回收,并将它们标记为“可用”,并在需要时重新分配给程序。这个过程是由操作系统的虚拟内存管理机制来完成的,具体的开销取决于操作系统的实现和硬件的性能等因素。

3.2 度量GC的开销

由于标记辅助技术的存在,单纯地从每个GC cycle的执行时间以及GC间隔时间来度量GC开销似乎就不那么准确了,更为直观的反映GC开销的是GC消耗cpu的占比

不过目前上没有特别好的工具可以特别直观且直接告诉你当前Go程序执行时GC CPU占用率。我们可以通过pprof工具或类似Pyroscope这样的持续profiling的图形化工具来间接查看GC的cpu占用。

比如:通过Pyroscope提供的火焰图,查看runtime.gcBgMarkWorker(runtime后台专用的用于GC标记阶段的goroutine执行的函数)和runtime.gcAssistAlloc(标记辅助时调用的函数)的cpu消耗时间。

更为完整的Go runtime metrics指标,可以查看metrics包的文档

注:GODEBUG=gctrace=1可以输出关于每个GC周期的详细信息,关于详细信息中各个字段的解读可以参见这里。更高级的选手还可以使用Go execution tracer工具来剖析GC的开销。

GC的CPU开销占比通常在25%以下,一旦超过这个负荷比例,就要考虑做调优了,Go保证GC cpu占用不会超过50%

4. 优化GC的开销

优化GC的开销是提高系统性能和响应速度的重要手段。

前面我们分析了Go GC开销的主要来源。下面就针对每种来源说说优化开销的可能性与手段。

4.1 缩短STW时间

我们知道一旦GC STW后,所有业务逻辑都将暂停,这期间的CPU由GC 100%占用,降低STW时间是降低gc cpu占比的好方法。不过STW的算法是Go核心团队把控的,降低每个GC周期的STW时间也是Go核心团队的不二职责。从用户层面是很难影响到单次STW时间的。

不过,我们可以通过减少GC次数来间接减少STW次数,从而降低GC CPU占比。当然减少GC次数对后面的所有优化手段都有效,这是一个总开关。

那么如何减少GC次数呢?我们先来了解GC的触发时机。Go GC触发时机大体分为三种:

  • 手动触发:调用runtime.GC()
  • 常规触发:Target heap memory = Live heap + (Live heap + GC roots) * GOGC / 100
  • sysmon后台周期性强制触发GC

我们看到,这三种触发时机我们能干预的只有常规触发,而常规触发的公式中,可以调整的只有GOGC这个参数(等价于debug.SetGCPercent())。GOGC默认值为100,也就是说当新分配heap内存的数量是上一周期的活跃heap内存的一倍的时候,触发GC:

如果我们将GOGC改为200,那么GC的触发间隔将增加,频度会下降,CPU开销会降低(6.4%->3.8%),如下图:

不过这是以整个程序的内存开销增大为代价的(40MB -> 60MB),并且对一般开发者而言,GOGC的值改起来确有风险,稍有不慎可能就会触发OMM killed。之前uber曾发表一篇文章,讲述了uber是如何通过在线自动调整GOGC参数来大幅降低CPU资源开销的,可以一看。

当然除了GOGC这一个唯一可调参数外,Go社区在降低GC频率方面也有自己的小妙招,比如之前经常使用的ballast(压舱石)技术。其原理就是在程序初始化时先分配一块大内存:

func main() {

    // Create a large heap allocation of 10 GiB
    ballast := make([]byte, 10<<30)

    // Application execution continues
    // ...
    runtime.KeepAlive(ballast) // make sure the ballast won't be collected
}

这块内存仅体现在VSZ中,即该程序进程的虚拟内存中,但并不占用程序进程的常驻内存(RSS)中。但一旦分配,Go GC就会将其算作是一个“活”堆内存对象,在计算下一次GC时就会将其作为上述公式中的live heap考量。如果ballast为10GB,那么GC就会在程序每新分配10GB内存时才会被触发。

注:RSS是这个进程目前在主内存(RAM)中拥有多少内存。VSZ是该进程总共有多少虚拟内存。

Go 1.19版本引入了Soft memory limit,这个方案在runtime/debug包中添加了一个名为SetMemoryLimit的函数以及GOMEMLIMIT环境变量,通过他们任意一个都可以设定Go应用的Memory limit。

一旦设定了Memory limit,当Go堆大小达到“Memory limit减去非堆内存后的值”时,一轮GC会被触发。即便你手动关闭了GC(GOGC=off),GC亦会被触发。 不过soft memory limit不保证不会出现oom-killed。并且如果一个Go应用的live heap object超过了soft memory limit但还尚未被kill,那么此时GC可能会被频繁触发,将大量消耗cpu资源:

但为了保证在这种情况下业务依然能继续进行,soft memory limit方案保证GC最多只会使用50%的CPU算力,以保证业务处理依然能够得到cpu资源。

那么多大的值是合理的soft memory limit值呢?在Go服务独占容器资源时,一个好的经验法则是留下额外的5-10%的空间。uber在其博客中设定的limit为资源上限的70%,也是一个不错的经验值。

Memory Limit被看作是Go官方的ballast替代方案,但还是不有所不同的。Memory limit只是规定了一个上限,如果未到memory limit,Go的常规GC还是会照例执行的。GOGC=off+ soft Memory limit下的行为特征与ballast更类似,不过将GC关掉的风险还是很大的,要三思而后行。

Go GC没有采用分代机制,每次都是FullGC,减少GC次数确是降低GC CPU开销的良方。不过除此之外,我们还有一个优化GC开销的方法,我们继续看。

4.2 减少堆内存的分配和释放

GC开销大的根源在于heap object多,Go的每轮GC都是FullGC,每轮都要将所有heap object标记(mark)一遍,即便大多数heap object都是长期alive的,因此,一个直观的降低GC开销的方法就是减少heap object的数量,即减少alloc

沿着这样的思路,我们可以很直接的想出如下两种手段:

  • 把小对象聚合到一个结构体中,然后做一次分配即可

这样不仅利于减少分配次数,还有利于减少堆内存碎片,提高堆内存的利用率。如果整个结构体中没有指针对象,那么结构体的分配与释放将更加高效,具体原因可参见我的《Go GC如何检测内存对象中是否包含指针》一文。

  • 重用

Go GC开销优化的一个典型手段就是内存空间重用,即建立一个池子,需要的时候从池中申请,用完后再放回池子里,供其他goroutine重用。这个过程不再有分配与释放。

Go中最典型的重用的例子就是sync.Pool的使用,不过sync.Pool并非完全不做释放操作,它是在一定程度上提高了重用的比例罢了。

5. 小结

Go GC的自动内存管理减少了内存泄漏和悬挂指针等问题。然而,GC给开发者带来便利的同时,开销也是不可避免的,它会对系统的性能和响应速度产生影响。Go开发者需要了解这些开销。

在本文中,我们介绍了GC的基本原理、GC的开销及其主要来源,并提供了优化GC开销的一些方法。

然而,要想有效地利用 GC,开发者需要了解其内部机制和算法,并根据实际情况进行调优。

除了通过GC参数降低GC频率外,在实际编码过程中,开发者还应该尽可能地减少对象的分配以降低Go每轮FullGC扫描对象的数量。

GC的优化是一项长期的工作。开发者应该不断地监控系统的性能和行为,并根据需要进行调整和优化,以确保系统的性能和响应速度始终保持在最佳状态。

6. 参考资料


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商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
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系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
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats