在Go语言里检测内存泄漏

我们先来设定一下数据库，建立一个MySQL数据库表，名为users，里面有login_name、nickname、uid、password、forbidden几个字段，其中uid与forbidden为int类型字段，其他均为varchar类型，而password为用户密码md5后的结果，因此长度均为32。我们使用的MySQL数据库引擎为go-sql-driver/mysql。

create database mytest default character set utf8;
use mytest ;

create table users(login_name varchar(20),nickname varchar(20),uid int(8),password char(32),forbidden tinyint(1));

insert into users value ('Alex','Sunday','12345678','827ccb0eea8a706c4c34a16891f84e7b','0');

　　

package main
import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"os"
	"os/signal"
	"runtime"
	"runtime/pprof"
	"strings"
	"time"
)

var (
	pid      int
	progname string
)

func init() {
	pid = os.Getpid()
	paths := strings.Split(os.Args[0], "/")
	paths = strings.Split(paths[len(paths)-1], string(os.PathSeparator))
	progname = paths[len(paths)-1]

	runtime.MemProfileRate = 1
}

func saveHeapProfile() {
	runtime.GC()

	f, err := os.Create(fmt.Sprintf("heap_%s_%d_%s.prof", progname, pid, time.Now().Format("2006_01_02_03_04_05")))
	if err != nil {
		return
	}
	defer f.Close()
	pprof.Lookup("heap").WriteTo(f, 1)
}

func waitForSignal() os.Signal {
	signalChan := make(chan os.Signal, 1)
	defer close(signalChan)

	signal.Notify(signalChan, os.Kill, os.Interrupt)
	s := <-signalChan
	signal.Stop(signalChan)
	return s
}

func connect(source string) *sql.DB {
	db, err := sql.Open("mysql", source)
	if err != nil {
		return nil
	}

	if err := db.Ping(); err != nil {
		return nil
	}

	return db
}

type User struct {
	uid       int
	name      string
	nick      string
	forbidden int
	cid       int
}

func query(db *sql.DB, name string, id int, dataChan chan *User) {
	for {
		time.Sleep(time.Millisecond)

		user := &User{
			cid:  id,
			name: name,
		}

		err := db.QueryRow("SELECT nickname, uid, forbidden FROM users WHERE login_name = ?", name).Scan(&user.nick, &user.uid, &user.forbidden)
		if err != nil {
			continue
		}

		dataChan <- user
	}
}

func main() {
	defer saveHeapProfile()

	db := connect("mytest:mytest@tcp(localhost:3306)/mytest?charset=utf8")
	if db == nil {
		return
	}

	userChan := make(chan *User, 100)
	for i := 0; i < 100; i++ {
		go query(db, "Alex", i+1, userChan)
	}

	allUsers := make([]*User, 1<<12)
	go func() {
		for user := range userChan {
			fmt.Printf("routine[%d] get user %+v\n", user.cid, user)
			allUsers = append(allUsers, user)
		}
	}()

	s := waitForSignal()

	fmt.Printf("signal got: %v, all users: %d\n", s, len(allUsers))
}

　　

上面的程序当然有蛮严重的内存泄漏问题，我们下面来看看如何加入代码，让pprof帮我们定位到产生内存泄漏的具体代码段里。

下面是内存泄漏问题诊断的一般流程：

1. 在命令行下 go build  编译生成一个可执行程序，例如叫做your-executable-name， 然后运行让其跑起来（会一直不停的跑直到你主动中断，系统会监控到中断信号 并将heap信息写入生成的文件中 我们称其为profile-filename）
2. 使用go tool pprof your-executable-name profile-filename即可进入pprof命令模式分析数据
3. 或者使用go tool pprof your-executable-name --text profile-filename查看各个函数/方法的内存消耗排名
4. 或者使用go tool pprof your-executable-name --dot profile-filename > heap.gv命令生成可以在graphviz里面看的gv文件，在查看各个方法/函数的内存消耗的同时查看它们之间的调用关系
5. 或者生成了gv文件之后通过dot -Tpng heap.gv > heap.png生成调用关系网与内存消耗图的png图形文件

之后执行go tool pprof your-executable-name --text profile-filename即可得到类似下面的结果(仅截取前几行)：


Adjusting heap profiles for 1-in-1 sampling rate
Total: 1.7 MB
0.7 40.4% 40.4% 1.0 56.2% github.com/go-sql-driver/mysql.(*MySQLDriver).Open
0.5 27.7% 68.1% 1.6 93.6% main.query
0.2 11.7% 79.8% 0.2 11.7% newdefer
0.1 6.9% 86.7% 0.1 6.9% database/sql.convertAssign
0.1 4.6% 91.3% 0.1 4.7% main.func路001
0.0 1.2% 92.5% 0.0 1.2% net.newFD
0.0 1.0% 93.5% 0.0 1.0% github.com/go-sql-driver/mysql.parseDSNParams
0.0 0.9% 94.5% 0.0 0.9% runtime.malg
0.0 0.6% 95.1% 0.0 0.6% runtime.allocm
0.0 0.5% 95.6% 0.0 0.5% resizefintab
0.0 0.5% 96.1% 0.0 0.5% github.com/go-sql-driver/mysql.(*mysqlConn).readColumns
0.0 0.5% 96.6% 0.0 0.5% database/sql.(*DB).addDepLocked


这个表格里每一列的意义参见perftool的这个文档。

运行go tool pprof命令，不带–-text参数后将直接进入pprof的命令行模式，可以首先执行top10，就可以得到与上述结果类似的排名，

从里面可以看到消耗内存最多的是mysql的Open方法，说明我们调用了Open方法后没有释放资源。

此外我们也可以运行go tool pprof your-executable-name --dot profile-filename > heap.gv，这样将得到一个heap.gv文件，我们在graphviz里面打开这个文件将得到一个更详细的包括调用关系在内的内存消耗图。当然，我们如果只需要一张图，也可以运行dot -Tpng heap.gv > heap.png将这个gv文件另存为png图，这样就可以像我一样，在下面展示剖析结果了。

除了在给定的时刻打印出内存剖析信息到文件里以外，如果你希望能够随时看到剖析结果，也可以有很简单的方法，那就是把net/http和net/http/pprof这两个包给import进来，其中net/http/pprof包需要以import _ "net/http/pprof"的方式导入，然后在代码里面加一个自定义端口(如6789)的http服务器，像这样：

go func(){
    http.ListenAndServe(":6789", nil)
}()

　　

这样，在程序运行起来以后，你就可以通过go tool pprof your-executable-name http://localhost:6789/debug/pprof/heap获得实时的内存剖析信息了，数据格式与通过文件保存下来的格式一致，之后的处理就都一样了。

在go tool pprof之后，进入pprof的命令行模式下，可以使用list命令查看对应函数(实际上是匹配函数名的正则表达式)里具体哪一行导致的性能/内存损耗。

转自：http://blog.raphaelzhang.com/2014/01/memory-leak-detection-in-go/