Go程序GC优化经验分享

作者：达达

来源：http://1234n.com/?post/yzsrwa

最近一段时间对《仙侠道》的服务端进行了一系列针对GC的调优，这里跟各位分享一下调优的经验。

游戏第一次上线的时候，大部分精力都投入在做cpuprof和memprof找性能瓶颈和内存泄漏上，没有关注过Go的GC运行情况。

有一次cpuprof里的scanblock调用所占的比例让我注意到Go的GC所带来的性能消耗，记得那份cpuprof里，scanblock调用占到49%。也就是说有一半的CPU时间浪费在了GC上。

于是我开始研究如何进行优化，过程中免不了要分析数据，经过一番搜索，我好到了GOGCTRACE这个环境变量。

用法类似这样：

GOGCTRACE=1 ./my_go_program 2> log_file

通过这个环境变量可以让Go程序在每次GC时都输出信息，信息是输出到标准错误的，所以需要用 2> 把输出重定向到文件里。

输出的内容像这样：

gc16(8): 34+6+5 ms, 367 -> 365 MB 817253 -> 782045 (18216892-17434847) objects, 64(2182) handoff, 72(22022) steal, 553/244/51 yields

其中gc16表示第16次进行GC，后面的(8)表示由8个线程执行，这个线程数对应GOMAXPROCS环境变量，34+6+5 ms分别代表一系列GC动作消耗的时间，这三个时间加起来45ms，就是这个程序在这次GC过程中暂停的时间。

后面接着的是内存、对象数量等，在GC前后的变化，其中最关键的是对象数量，这边可以看到GC后还有782045个对象存在。

我在实际游戏服和内网开发测试服都开启了GOGCTRACE，发现GC暂停时间相差甚大，当时（还未做第一次优化前）外网GC暂停达到400多ms，而内网才20ms。

显然跟内存中数据多少有关系，于是我推测跟内存中对象数量关系最大，原因很简单，假设我是GC开发者，不可能让一个对象占用100M内存跟一万个对象占用100M内存同样消耗性能，显然那一个占用100M内存的对象，当我发现它不需要回收的话，我就不需要做什么事情了，而那一万个对象，我需要逐个检查是否还有被引用，所以内存大小不是关键，对象数量才是关键。

于是我按这个推测进行了第一次性能优化，我把存储游戏内存数据的链表结构改为slice，当初设计成链表是因为数据有插入和删除，slice可以扩容但是要收缩就比较麻烦了，于是想到了链表，链表要删除单个节点的时候，只需要把节点从链表上断开，不需要复制数据，效率高于数组结构。这里直观的表示一下两种数据结构的区别：

    type MyData1 struct {
        next *MyData
        Id   int
        Name string
    }

    var mydata1 *MyData1

    type MyData2 struct {
        Id   int
        Name string
    }

    var mydata2 []MyData2

上面示例代码的mydata1用的是链表结构，每个节点都有一个指向下一个节点的指针，想像下存储1万个对象到mydata1，是不是需要创建1万个MyData1类型的对象。

示例中的mydata2用的是slice结构，一个slice就是一个对象，其中的元素都是这一块内存中的值，而不是对象，需要注意 []MyData2 和 []*MyData2 是不一样的，如果换用第二种写法，那么每个元素一样都是一个对象，因为这时候slice存的不是值而是指向对象的指针，而这些指针每一个都分别指到一个对象。

我做了一组不同数据结构跟对象数量关系的实验，可以直观的感受区别：github链接

经过这番改造，对象数量少了一个数量级，具体对少对象我已经记不得了，但是可以自己估计一下，一个mydata1这样的内存表，假设平均20条记录，假设有50个这样的表，就是1000个对象，换成mydata2这样的内存表，就只要50个对象。

当然这样一换，内存占用肯定就上去了，但是实际观测下来，内存占用在可接收范围，甚至还是远小于之前我用erlang开发的游戏，而GC扫描时间从300多ms降到几十ms，降了一个数量级。

本来优化到此我就打算告一段落了，但是随着游戏的持续运行，数据的持续增加，我发现slice自身占用的对象数量也还是值得动动脑筋消除掉的，线上GC暂停时间最高的服务器，达到了100ms，如果再涨上去，一样还是可能达到200ms设置300ms。

所以又继续懂了一些脑筋，比如把玩家数据压缩起来，等需要用的时候再解开来用，尝试过json序列化等等，目的都是把多个对象归并成一个。

但是这些方案都是牺牲数据访问的效率为代价的，需要访问数据时就要反序列化展开数据。

其实在第一次优化时，我大部分时间花在尝试cgo上面，而不是尝试slice上，我第一个思路是用cgo申请内存，伪造成go的对象，这些对象就不受Go的GC管理里，也就不会对GC有负担。但是尝试下来，总是遇到各种指针异常，我可以确信不是我的指针运算问题，但是为什么自己申请的内存会影响到Go的执行，我一直弄不明白，时间不等人，不可能一直研究下去，所以我才想了slice的这个方案，不是最优解但至少暂时解决问题。

而这一次，因为使用了slice，原先的内存数据库的数据结构就变得很单一，而优化的目的也明显，减少slice的内存消耗。正好那阵子我在尝试将SpiderMonkey嵌入到Go，接触到了cgo操作slice的一些技巧，比如将C的数组映射成Go的slice，或者利用reflect.SliceHeader取得slice所指向的内存块地址，然后用cgo复制数据。

于是我就想到用C来申请slice所需内存块，然后自己构造SliceHeader的办法。

这里需要说明下SliceHader和slice之间的关系。

Go提供了一个很有用的数据结构slice，slice比起C时代的数值有很明显的优势，有边界判断、可以反复切割、没有牺牲运行效率，如何做到的呢？官方这片文章有很清楚的说明：点击查看

简单说来，Go的slice其实是一个三个字段的结构体，三个字段分别存放着slice的当前长度、内存块的大小和实际内存块的地址，每次len(slice)的时候是不需要循环计算长度的，只是到结构体里去一下长度，而重新切割的过程，只是重新构造一个指向同一个内存块或块中某一位置的过程，所以不会有内存拷贝和循环等消耗性能的操作。

这个三个字段的结构体，在Go的反射包里面使用SliceHeader类型表示，这让我们的程序有机会构造自己的SliceHeader。

cgo的wiki文档里有这样一段示例代码，演示如何把C的数组包装成Go的slice：

import "C"
import "unsafe"
...
        var theCArray *TheCType := C.getTheArray()
        length := C.getTheArrayLength()
        var theGoSlice []TheCType
        sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&theGoSlice)))
        sliceHeader.Cap = length
        sliceHeader.Len = length
        sliceHeader.Data = uintptr(unsafe.Pointer(&theCArray[0]))
        // now theGoSlice is a normal Go slice backed by the C array

这边用到了unsafe.Pointer，通过Pointer类型，我们可以在Go的程序里实现指针运算，之前我有写过相关文章，这里就不重复介绍了：点击查看

于是我将内存数据库用到的slice类型全部换成自己用C伪造的slice，还好当初内存数据库用的是代码生成器，否则代码就要改死掉了 ：）

全部替换完后，我拿外网同样数据对比，优化前的程序GC扫描时间100多ms，对象数量140万，优化后的程序GC扫描时间18ms，对象数量16万。

本来可以就这样打完收功了，但是生活总是充满戏剧性，内网测试的时候发现好友列表里面的名字全乱码了，肯定跟优化有关系，但为什么会乱码呢？

我的推测是go构造的字符串对象被C构造的对象引用，这样的引用导致go把字符串对象当成没人使用，于是就被回收利用了。

我只好把所有字符串字段也全部改为C伪造的对象，原理给伪造slice是一样的，不同的是字符串用StringHeader表示。

经过改造，字符串再也不会乱码了，不过需要很小心的释放内存。

优化过程中Go提供的pprof模块起到了很重要的作用，所有的优化都是以数据为依据的，如果不能看到数据就没有办法定位问题。

程序中可以用 pprof.Lookup("heap") 来获得堆信息，其中包含了对象数量和GC执行时间等有用的数据。

上次群里有人问 map[int]XXX 这样的数据结构是否会有GC问题，正好这个数据结构我之前也考虑过，也在上面的数据结构实验里体现了，map[int]XXX 和 map[int]XXX是一样的，一条数据就是一个对象，对GC是否有影响取决于对象的数量。

从上面的观测数值来看百来万的对象数量所造成的暂停应该还不足以影响程序，除非应用场景对实时性要求非常高。

但是对于游戏这样的常驻内存程序来说，对象的增长速度和对象数量上限也需要留意，比如刚开始对象数量只有几万，随着日子增长，玩家数据增多，对象数量达到百万千万，那时候可能就会有影响了。

之前第一次优化过后正好有人在知乎问Go的GC情况，我回了一帖，里面有比较详细的第一次优化的数据，大家可以参考一下：点击查看

Go 的垃圾回收机制在实践中有哪些需要注意的地方？

来源：http://www.zhihu.com/question/21615032/answer/18781477

不想看长篇大论的，这里先给个结论，go的gc还不完善但也不算不靠谱，关键看怎么用，尽量不要创建大量对象，也尽量不要频繁创建对象，这个道理其实在所有带gc的编程语言也都通用。

想知道如何提前预防和解决问题的，请耐心看下去。

先介绍下我的情况，我们团队的项目《仙侠道》在7月15号第一次接受玩家测试，这个项目的服务端完全用Go语言开发的，游戏数据都放在内存中由go 管理。

在上线测试后我对程序做了很多调优工作，最初是稳定性优先，所以先解决的是内存泄漏问题，主要靠memprof来定位问题，接着是进一步提高性能，主要靠cpuprof和自己做的一些统计信息来定位问题。

调优性能的过程中我从cpuprof的结果发现发现gc的scanblock调用占用的cpu竟然有40%多，于是我开始搞各种对象重用和尽量避免不必要的对象创建，效果显著，CPU占用降到了10%多。

但我还是挺不甘心的，想继续优化看看。网上找资料时看到GOGCTRACE这个环境变量可以开启gc调试信息的打印，于是我就在内网测试服开启了，每当go执行gc时就会打印一行信息，内容是gc执行时间和回收前后的对象数量变化。

我惊奇的发现一次gc要20多毫秒，我们服务器请求处理时间平均才33微秒，差了一个量级别呢。

于是我开始关心起gc执行时间这个数值，它到底是一个恒定值呢？还是更数据多少有关呢？

我带着疑问在外网玩家测试的服务器也开启了gc追踪，结果更让我冒冷汗了，gc执行时间竟然达到300多毫秒。go的gc是固定每两分钟执行一次，每次执行都是暂停整个程序的，300多毫秒应该足以导致可感受到的响应延迟。

所以缩短gc执行时间就变得非常必要。从哪里入手呢？首先，可以推断gc执行时间跟数据量是相关的，内网数据少外网数据多。其次，gc追踪信息把对象数量当成重点数据来输出，估计扫描是按对象扫描的，所以对象多扫描时间长，对象少扫描时间短。

于是我便开始着手降低对象数量，一开始我尝试用cgo来解决问题，由c申请和释放内存，这部分c创建的对象就不会被gc扫描了。

但是实践下来发现cgo会导致原有的内存数据操作出些诡异问题，例如一个对象明明初始化了，但还是读到非预期的数据。另外还会引起go运行时报申请内存死锁的错误，我反复读了go申请内存的代码，跟我直接用c的malloc完全都没关联，实在是很诡异。

我只好暂时放弃cgo的方案，另外想了个法子。一个玩家有很多数据，如果把非活跃玩家的数据序列化成一个字节数组，就等于把多个对象压缩成了一个，这样就可以大量减少对象数量。

我按这个思路用快速改了一版代码，放到外网实际测试，对象数量从几百万降至几十万，gc扫描时间降至二十几微秒。

效果不错，但是要用玩家数据时要反序列化，这个消耗太大，还需要再想办法。

于是我索性把内存数据都改为结构体和切片存放，之前用的是对象和单向链表，所以一条数据就会有一个对象对应，改为结构体和结构体切片，就等于把多个对象数据缩减下来。

结果如预期的一样，内存多消耗了一些，但是对象数量少了一个量级。

其实项目之初我就担心过这样的情况，那时候到处问人，对象多了会不会增加gc负担，导致gc时间过长，结果没得到答案。

现在我填过这个坑了，可以确定的说，会。大家就不要再往这个坑跳了。

如果go的gc聪明一点，把老对象和新对象区别处理，至少在我这个应用场景可以减少不必要的扫描，如果gc可以异步进行不暂停程序，我才不在乎那几百毫秒的执行时间呢。

但是也不能完全怪go不完善，如果一开始我早点知道用GOGCTRACE来观测，就可以比较早点发现问题从而比较根本的解决问题。但是既然用了，项目也上了，没办法大改，只能见招拆招了。

总结以下几点给打算用go开发项目或已经在用go开发项目的朋友：
1、尽早的用memprof、cpuprof、GCTRACE来观察程序。
2、关注请求处理时间，特别是开发新功能的时候，有助于发现设计上的问题。
3、尽量避免频繁创建对象(&abc{}、new(abc{})、make())，在频繁调用的地方可以做对象重用。
4、尽量不要用go管理大量对象，内存数据库可以完全用c实现好通过cgo来调用。

手机回复打字好累，先写到这里，后面再来补充案例的数据。

数据补充：

图1，7月22日的一次cpuprof观测，采样3000多次调用，数据显示scanblock吃了43.3%的cpu。

图2，7月23日，对修改后的程序做cpuprof，采样1万多次调用，数据显示cpu占用降至9.8%

数据1，外网服务器的第一次gc trace结果，数据显示gc执行时间有400多ms，回收后对象数量1659922个：

gc13(1): 308+92+1 ms , 156 -> 107 MB 3339834 -> 1659922 (12850245-11190323) objects, 0(0) handoff, 0(0) steal, 0/0/0 yields

gc14(6): 16+15+1 ms, 75 -> 37 MB 1409074 -> 126097 (10335326-10209229) objects, 45(1913) handoff, 34(4823) steal, 455/283/52 yields

// 玩家数据表的集合
type tables struct {
        tableA *tableA
        tableB *tableB
        tableC *tableC
        // ...... 此处省略一大堆表
}

// 每个玩家只会有一条tableA记录
type tableA struct {
        fieldA int
        fieldB string
}

// 每个玩家有多条tableB记录
type tableB struct {
        xxoo int
        ooxx int
        next *tableB  // 指向下一条记录
}

// 每个玩家只有一条tableC记录
type tableC struct {
        id int
        value int64
}

// 玩家数据表的集合
type tables struct {
        tableA tableA
        tableB []tableB
        tableC tableC
        // ...... 此处省略一大堆表
}

// 每个玩家只会有一条tableA记录
type tableA struct {
        _is_nil bool
        fieldA int
        fieldB string
}

// 每个玩家有多条tableB记录
type tableB struct {
        _is_nil bool
        xxoo int
        ooxx int
}

// 每个玩家只有一条tableC记录
type tableC struct {
        _is_nil bool
        id int
        value int64
} 

有疑问加站长微信联系（非本文作者）