这一部分主要介绍golang gc的一些入门的相关知识，由于gc内容涉及比较多，一点一点慢慢整理。

Golang GC的背景

• golang是基于garbage collection的语言，这是它的设计原则。
• 作为一个有垃圾回收器的语言，gc与程序交互时候的效率会影响到整个程序的运行效率。
• 通常程序本身的内存管理会影响gc和程序之间的效率，甚至造成性能瓶颈。

Golang GC的相关问题

主要参的这个：

http://morsmachine.dk/machine-gc

是14年写的，估计那个时候的gc机制还比较simple，新版本的golang对gc的改动应该会比较大

还有那个go语言读书笔记中关于golang gc 的相关部分

关于内存泄露

“内存泄露”（Memory Leak）这个词看似自己很熟悉，可实际上却也从没有看过它的准确含义。

内存泄露，是从操作系统的角度上来阐述的，形象的比喻就是“操作系统可提供给所有进程的存储空间(虚拟内存空间)正在被某个进程榨干”，导致的原因就是程序在运行的时候，会不断地动态开辟的存储空间，这些存储空间在在运行结束之后后并没有被及时释放掉。应用程序在分配了某段内存之后，由于设计的错误，会导致程序失去了对该段内存的控制，造成了内存空间的浪费。

如果程序在内存空间内申请了一块内存，之后程序运行结束之后，没有把这块内存空间释放掉，而且对应的程序又没有很好的gc机制去对程序申请的空间进行回收，这样就会导致内存泄露。

从用户的角度来说，内存泄露本身不会有什么危害，因为这不是对用户功能的影响，但是“内存泄露”如果进

对于C和C++这种没有Garbage Collection 的语言来讲，我们主要关注两种类型的内存泄漏：

• 堆内存泄漏（Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak.

• 系统资源泄露（Resource Leak）.主要指程序使用系统分配的资源比如 Bitmap,handle ,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。

内存泄露涉及到的相关问题还有很多，这里暂不展开讨论。

常见的GC模式

具体的优缺点可以参考这个，这里只是进行大致介绍。

• 引用计数（reference counting）每个对象维护一个引用计数器，当引用该对象的对象被销毁或者更新的时候，被引用对象的引用计数器自动减1，当被应用的对象被创建，或者赋值给其他对象时，引用+1，引用为0的时候回收，思路简单，但是频繁更新引用计数器降低性能，存在循环以引用（php，Python所使用的）

• 标记清除（mark and sweep）就是golang所使用的，从根变量来时遍历所有被引用对象，标记之后进行清除操作，对未标记对象进行回收，缺点：每次垃圾回收的时候都会暂停所有的正常运行的代码，系统的响应能力会大大降低，各种mark&swamp变种（三色标记法），缓解性能问题。

• 分代搜集（generation）jvm就使用的分代回收的思路。在面向对象编程语言中，绝大多数对象的生命周期都非常短。分代收集的基本思想是，将堆划分为两个或多个称为代（generation）的空间。新创建的对象存放在称为新生代（young generation）中（一般来说，新生代的大小会比 老年代小很多），随着垃圾回收的重复执行，生命周期较长的对象会被提升（promotion）到老年代中（这里用到了一个分类的思路，这个是也是科学思考的一个基本思路）。

因此，新生代垃圾回收和老年代垃圾回收两种不同的垃圾回收方式应运而生（先分类，之后再对症下药），分别用于对各自空间中的对象执行垃圾回收。新生代垃圾回收的速度非常快，比老年代快几个数量级，即使新生代垃圾回收的频率更高，执行效率也仍然比老年代垃圾回收强，这是因为大多数对象的生命周期都很短，根本无需提升到老年代。

golang中的gc通常是如何工作的

golang中的gc基本上是标记清除的思路：

在内存堆中（由于有的时候管理内存页的时候要用到堆的数据结构，所以称为堆内存）存储着有一系列的对象，这些对象可能会与其他对象有关联（references between these objects） a tracing garbage collector 会在某一个时间点上停止原本正在运行的程序，之后它会扫描runtime已经知道的的object集合（already known set of objects），通常它们是存在于stack中的全局变量以及各种对象。gc会对这些对象进行标记，将这些对象的状态标记为可达，从中找出所有的，从当前的这些对象可以达到其他地方的对象的reference，并且将这些对象也标记为可达的对象，这个步骤被称为mark phase，即标记阶段，这一步的主要目的是用于获取这些对象的状态信息。

一旦将所有的这些对象都扫描完，gc就会获取到所有的无法reach的对象（状态为unreachable的对象），并且将它们回收，这一步称为sweep phase，即是清扫阶段。

gc仅仅搜集那些未被标记为可达（reachable）的对象。如果gc没有识别出一个reference，最后有可能会将一个仍然在使用的对象给回收掉，就引起了程序运行错误。

可以看到主要的三个步骤：扫描，回收，清扫。

感觉比起其他的语言，golang中的垃圾回收模型还是相对简单的。

gc中的问题

gc的引入可以说就是为了解决内存回收的问题。新开发的语言（java，python，php等等），在使用的时候，可以使用户不必关心内存对象的释放，只需要关心对象的申请即可，通过在runtime或者在vm中进行相关的操作，达到自动管理内存空间的效果，这种对不再使用的内存资源进行自动回收的行为就被称为垃圾回收。

根据前面的表述，能否正常识别一个reference是gc能够正常工作的基础，因此第一个问题就是gc应该如何识别一个reference？

最大的问题：对于reference的识别比较难，machine code 很难知道，怎样才算是一个reference。如果错漏掉了一个reference，就会使得，原本没有准备好要被free掉的内存现在被错误地free掉，所以策略就是宁多勿少。

一种策略是把所有的memory空间都看做是有可能的references（指针值）。这种被称为保守型垃圾回收器（conservative garbage collector）。C 中的Boehm garbage collector就是这样工作的。就是说把内存中的普通变量也当做指针一样去处理，尽量cover到所有的指针的情况，如果碰巧这个普通的变量值所指向的空间有其他的对象，那么这个对象是不会被回收的。而go语言实现是完全知道对象的类型信息，在标记时只会遍历指针指向的对象，这样就避免了C实现时的堆内存浪费（解决约10-30%）。

三色标记

2014/6 1.3 引入并发清理（垃圾回收和用户逻辑并发执行？）

2015/8 1.5 引入三色标记法

关于并发清理的引入，参照的是这里在1.3版本中，go runtime分离了mark和sweep的操作，和以前一样，也是先暂停所有任务执行并启动mark（mark这部分还是要把原程序停下来的），mark完成后就马上就重新启动被暂停的任务了，并且让sweep任务和普通协程任务一样并行，和其他任务一起执行。如果运行在多核处理器上，go会试图将gc任务放到单独的核心上运行而尽量不影响业务代码的执行，go team自己的说法是减少了50%-70%的暂停时间。

基本算法就是之前提到的清扫+回收，Golang gc优化的核心就是尽量使得STW(Stop The World)的时间越来越短。

如何测量GC

之前说了那么多，那如何测量gc的之星效率，判断它到底是否对程序的运行造成了影响呢？ 第一种方式是设置godebug的环境变量，具体可以参考这一篇，真的是讲的很好的文章：链接，比如运行GODEBUG=gctrace=1 ./myserver，如果要想对于输出结果了解，还需要对于gc的原理进行更进一步的深入分析，这篇文章的好处在于，清晰的之处了golang的gc时间是由哪些因素决定的，因此也可以针对性的采取不同的方式提升gc的时间：

根据之前的分析也可以知道，golang中的gc是使用标记清楚法，所以gc的总时间为：

Tgc = Tseq + Tmark + Tsweep(T表示time)

• Tseq表示是停止用户的 goroutine 和做一些准备活动（通常很小）需要的时间
• Tmark 是堆标记时间，标记发生在所有用户 goroutine 停止时，因此可以显著地影响处理的延迟
• Tsweep 是堆清除时间，清除通常与正常的程序运行同时发生，所以对延迟来说是不太关键的

之后粒度进一步细分，具体的概念还是有些不太懂：

• 与Tmark相关的：1 垃圾回收过程中，堆中活动对象的数量，2 带有指针的活动对象占据的内存总量 3 活动对象中的指针数量。
• 与Tsweep相关的：1 堆内存的总量 2 堆中的垃圾总量

如何进行gc调优（gopher大会 Danny）

硬性参数

涉及算法的问题，总是会有些参数。GOGC参数主要控制的是下一次gc开始的时候的内存使用量。

比如当前的程序使用了4M的对内存（这里说的是堆内存），即是说程序当前reachable的内存为4m，当程序占用的内存达到reachable*(1+GOGC/100)=8M的时候，gc就会被触发，开始进行相关的gc操作。

如何对GOGC的参数进行设置，要根据生产情况中的实际场景来定，比如GOGC参数提升，来减少GC的频率。

小tips

想要有深入的insights，使用gdb时必不可少的了，这篇文章里面整理了一些gdb使用的入门技巧。

减少对象分配 所谓减少对象的分配，实际上是尽量做到，对象的重用。 比如像如下的两个函数定义：

1
2

func(r*Reader)Read()([]byte,error)
func(r*Reader)Read(buf[]byte)(int,error)

第一个函数没有形参，每次调用的时候返回一个[]byte，第二个函数在每次调用的时候，形参是一个buf []byte 类型的对象，之后返回读入的byte的数目。

第一个函数在每次调用的时候都会分配一段空间，这会给gc造成额外的压力。第二个函数在每次迪调用的时候，会重用形参声明。

老生常谈 string与[]byte转化 在stirng与[]byte之间进行转换，会给gc造成压力 通过gdb，可以先对比下两者的数据结构：

1
2
3

type = struct []uint8 {    uint8 *array;    int len;    int cap;}

type = struct string {    uint8 *str;    int len;}

两者发生转换的时候，底层数据结结构会进行复制，因此导致gc效率会变低。解决策略上，一种方式是一直使用[]byte，特别是在数据传输方面，[]byte中也包含着许多string会常用到的有效的操作。另一种是使用更为底层的操作直接进行转化，避免复制行为的发生。可以参考微信“雨痕学堂”中性能优化的第一部分，主要是使用unsafe.Pointer直接进行转化。

对于unsafe的使用，感觉可以单独整理一出一篇文章来了，先把相关资料列在这里 http://studygolang.com/articles/685 直观上，可以把unsafe.Pointer理解成c++中的void*，在golang中，相当于是各种类型的指针进行转化的桥梁。

关于uintptr的底层类型是int，它可以装下指针所指的地址的值。它可以和unsafe.Pointer进行相互转化，主要的区别是，uintptr可以参与指针运算，而unsafe.Pointer只能进行指针转化，不能进行指针运算。想要用golang进行指针运算，可以参考这个。具体指针运算的时候，要先转成uintptr的类型，才能进一步计算，比如偏移多少之类的。

少量使用+连接string 由于采用+来进行string的连接会生成新的对象，降低gc的效率，好的方式是通过append函数来进行。

但是还有一个弊端，比如参考如下代码：

1

b := make([]int, 1024)   b = append(b, 99)   fmt.Println("len:", len(b), "cap:", cap(b))

在使用了append操作之后，数组的空间由1024增长到了1312，所以如果能提前知道数组的长度的话，最好在最初分配空间的时候就做好空间规划操作，会增加一些代码管理的成本，同时也会降低gc的压力，提升代码的效率。

参考资料

https://talks.golang.org/2015/go-gc.pdf

https://www.zhihu.com/question/21615032

https://blog.golang.org/go15gc

golang gc 中文入门（总结比较全面 包括golang gc 在不同版本的比较 赞） http://www.open-open.com/lib/view/open1435846881544.html(原文)

其他垃圾回收相关文章

这个介绍的gc较为系统： http://newhtml.net/v8-garbage-collection/

1.5版本的垃圾回收器 http://ruizeng.net/go-15-release-notes/

内存泄露参考 http://blog.csdn.net/na_he/article/details/7429171

Go1.5源码剖析 https://github.com/qyuhen/book

手动管理golang gc的一个例子（比较深层次的内容） http://my.oschina.net/lubia/blog/175154