Go语言-调试

摘要

本文部分内容来源于网络，个人收集整理，请勿传播

参考：

http://blog.sina.com.cn/s/blog_884e78b20101hmvf.html

http://lincolnloop.com/blog/introduction-go-debugging-gdb/

http://blog.studygolang.com/2012/12/gdb调试go程序/

1、检查gdb的版本号。Go官方文档里有句话：Go apps can be debugged with gdb 7.1 and higher. 所以只有7.1及以上版本的gdb才支持go代码的调试。

因为开发机中版本没有达到7.1，如下示：

接下来gdb调试go代码的过程就以个人虚拟机上的gdb来叙述。虚拟机上gdb版本号为7.2，如下示：

2、调试用的demo程序代码如下：

// main.go

package main

import (

"fmt"

"runtime"

)

func test(s string, x int) (r string) {

r = fmt.Sprintf("test: %s %d", s, x)

runtime.Breakpoint()

return r

}

func main() {

s := "haha"

i := 1234

println(test(s, i))

}

3、编译，并关闭代码优化功能： go build –gcflags “-N -l” main.go

4、启动gdb调试器

输入gdb main然后回车

5、手动载入go runtime，这个很重要，如果没有载入的话，gdb就无法识别go语言了。这个也只有gdb 7.1以上才会有的。

输入命令：

(gdb) source ~/go/src/pkg/runtime/runtime-gdb.py

Loading Go Runtime support. （出现这个提示则表明加载go runtime成功了）

6、以点号方式查看某函数（如main函数）的源码：

(gdb) l main.main

8 func test(s string, x int) (r string) {

9 r = fmt.Sprintf("test: %s %d", s, x)

10 runtime.Breakpoint()

11 return r

12 }

13 func main() {

14 s := "haha"

15 i := 1234

16 println(test(s, i))

17 }

7、以冒号方式查看某行（如第8行）前后的源码：

(gdb) l main.go:8

3 import (

4 "fmt"

5 "runtime"

6 )

7

8 func test(s string, x int) (r string) {

9 r = fmt.Sprintf("test: %s %d", s, x)

10 runtime.Breakpoint()

11 return r

12 }

8、以点号方式设置某个函数（如main函数）入口为断点：

(gdb) b main.main

Breakpoint 1 at 0x8048d20: file /home/vobin/main.go, line 13.

9、以冒号方式设置某一行处（如第16行）为断点：

(gdb) b main.go:16

Breakpoint 2 at 0x8048d5d: file /home/vobin/main.go, line 16.

10、查看所有断点信息：

(gdb) info breakpoints

Num Type Disp Enb Address What

1 breakpoint keep y 0x08048d20 in main.main

at /home/vobin/main.go:13

2 breakpoint keep y 0x08048d5d in main.main

at /home/vobin/main.go:16

11、启动进程，触发第一个断点：

(gdb) r

Starting program: /home/vobin/main

Breakpoint 1, main.main () at /home/vobin/main.go:13

13 func main() {

12、查看goroutines信息：

(gdb) info goroutines

* 1 running runtime.malg

2 runnable runtime.goexit

13、产看指定序号（如序号1）的goroutine的调用堆栈信息：

(gdb) goroutine 1 bt

#0 0x0805aec2 in runtime.malg (stacksize=void)

at /usr/local/go/src/pkg/runtime/proc.c:1454

#1 0x0000001d in ?? ()

#2 0x1823d000 in ?? ()

14、继续执行，触发下一个断点：

(gdb) c

Continuing.

Breakpoint 2, main.main () at /home/vobin/main.go:16

16 println(test(s, i))

15、查看当前调用堆栈信息：

(gdb) bt

#0 main.main () at /home/vobin/main.go:16

#1 0x080588df in runtime.main () at /usr/local/go/src/pkg/runtime/proc.c:182

#2 0x0805a5a0 in ?? () at /usr/local/go/src/pkg/runtime/proc.c:1218

16、查看当前堆栈帧信息：

(gdb) info frame

Stack level 0, frame at 0xb7b79fc4:

eip = 0x8048d5d in main.main (/home/vobin/main.go:16); saved eip 0x80588df

called by frame at 0xb7b79fdc

source language minimal.

Arglist at 0xb7b79f90, args:

Locals at 0xb7b79f90, Previous frame's sp is 0xb7b79fc4

Saved registers:

eip at 0xb7b79fc0, st5 at 0xb7b79fc0

17、查看当前的局部变量：

(gdb) info locals

s = "haha"

i = 1234

18、查看某个变量（如变量s）的值：

(gdb) p s

$1 = "haha"

19、查看当前断点附近的源码：

(gdb) l

11 return r

12 }

13 func main() {

14 s := "haha"

15 i := 1234

16 println(test(s, i))

17 }

19、查看变量（如变量i）的类型：

(gdb) what i

type = int

20、执行源码的下一行代码：

(gdb) n

main.test (s="haha", x=1234, r="test: haha 1234") at /home/vobin/main.go:11

11 return r

21、查看参数信息，可以看到返回参数的值：

(gdb) info args

s = "haha"

x = 1234

r = "test: haha 1234"

22、查看某变量（如变量r）的内存数据：

(gdb) x/3xw &r

0xb7b79fa0: 0x18245030 0x0000000f 0x080ce5b8

总结：gdb调试go代码，使用的命令和gdb调试c/c++差别不大。有一点差异的地方是：如果当前没有处于断点状态，使用l命令是查看不了源码的。所以在启动gdb之后但没有设置断点之前，查看源码都是通过点号或者分号方式。

三、 Go代码的静态检查

Go安装目录里有个自带的小工具gofmt（所在位置：~/go/bin/gofmt），可以用来很方便的检查go程序的语法正确性并格式化代码。

具体使用方法为：gofmt –w test.go 其中test.go为目标go代码文件，-w选项表示会把格式化后的代码覆盖掉原来非格式化的代码。

如果go代码文件出现格式或简单语法错误（if语句大括号不匹配， 大括号换行了、多了分号、少了逗号， 关键字拼写错误等），会打印出错误提示信息，提示在哪一行哪一列有问题。

gofmt只能用来检查简单语法和代码格式错误，但不能用来检查很深层次的错误，比如给一个没有申明的变量赋值，初始化了变量但之后再没使用过它，引入的package不存在，引入了package但这个package并没有被使用等等各种情形，这种情况下可以在之前gofmt操作完之后再使用go build来编译下，彻底清除深层次的错误。

以下为一个简单的示例：

// main.go

1 package main

2

3 import (

4 "fmt"

5 "timed" // package name error

6 )

7

8 func counting(c chan<- int) {

9 ford i := 0; i < 10; i++ { // the keyword "ford" is unknown

10 time.Sleep(2 * time.Second)

11 c <- i

12 }

13 close(c)

14 }

15

16 func cre() { // no main function

17 msg := "Starting main"

18 fmt.Println(msg)

19 bus := make(chan int)

20 msg = "starting a gofunc"

21 go counting(bus)

22 for count := range bus {

23 fmt.Println("count: ", count)

24 }

25 }

执行gofmt命令后：

[wangshibing@yf-oped-dev02.yf01.baidu.com go-project]$ gofmt -w main.go

main.go:9:16: expected ';', found 'IDENT' i

提示说第9行第16列处有问题， ford这个关键字不存在。

将ford改为for之后，再执行gofmt命令就没有错误提示了。

然后，使用go build来挖出深层次错误。执行go build main.go：

[wangshibing@yf-oped-dev02.yf01.baidu.com go-project]$ go build main.go

main.go:5:2: cannot find package "timed" in any of:

/home/users/wangshibing/go/src/pkg/timed (from $GOROOT)

($GOPATH not set)

提示第5行第2列的timed包不存在。将timed改成time后，重新执行go build main.go：

[wangshibing@yf-oped-dev02.yf01.baidu.com go-project]$ go build main.go

# command-line-arguments

runtime.main: undefined: main.main

上面的错误说，这是个main包，但是没有定义main函数。因为go语言规定package main包里必须要有对main函数的定义。将cre改为main之后，重新执行go build main.go后，没有出现任何错误提示了。

四、 GO程序单元测试

参考： http://www.cnblogs.com/yjf512/archive/2013/01/22/2870927.html

http://blog.gcove.net/go语言测试test.html

http://chenxiaoyu.org/2012/12/07/golang-module-test-benchmark.html

http://godoc.org/testing

Go语言通过testing包提供自动化单元测试功能。包内测试只要运行命令 go test，就能自动运行符合规则的测试函数。

Go语言测试约定规则：

1.一般的测试func TestXxx(*testing.T)

测试行必须Test开头，Xxx为字符串，第一个X必须大写的[A-Z]的字幕

为了测试方法和被测试方法的可读性，一般Xxx为被测试方法的函数名。

2.性能测试func BenchmarkXxx(*testing.B)

性能测试用Benchmark标记，Xxx同上。

3.测试文件名约定

go语言测试文件名约定规则是必须以_test.go结尾，放在相同包下，为了方便代码阅读，一般go源码文件加上_test。比如源文件my.go 那么测试文件如果交your_test.go, her_test.go, my_test.go都可以，不过最好的还是my_test.go，方便阅读

测试demo如下：

待测试模块的代码如下：handle.go

// handle.go

package handle

func Add(a, b int) int {

return a + b

}

对应的测试代码如下：handle_test.go

// handle_test.go

package foo

import "testing"

func TestAdd(t *testing.T) {

if (Add(1, 2) = 3) {

t.Error("test foo:Addr failed")

} else {

t.Log("test foo:Addr pass")

}

}

要保证是handle_test.go和handle.go 在同一目录下。

测试方法如下：

1、然后切换到该目录下，执行以下的命令：

[wangshibing@yf-oped-dev02.yf01.baidu.com test]$ go test -v

= RUN TestAdd

PASS: TestAdd (0.00 seconds)
handle_test.go:9: test foo:Addr pass

PASS

ok _/home/users/wangshibing/go-project/test 0.008s

测试的结果是： PASS（通过），测试耗时0.008秒

2、将handle_test.go中Add(1, 2) = 3 改为 Add(1, 2) = 4，再次执行go test –v，结果如下：

[wangshibing@yf-oped-dev02.yf01.baidu.com test]$ go test -v

= RUN TestAdd

FAIL: TestAdd (0.00 seconds)
handle_test.go:7: test foo: Addr failed

FAIL

exit status 1

FAIL _/home/users/wangshibing/go-project/test 0.008s

测试的结果是：FAIL（失败），测试耗时0.008秒

3、在handle_test.go中追加一段性能测试代码如下：

func BenchmarkAdd(b *testing.B) {

for i := 0; i < b.N; i++ {

Add(1, 2)

}

}

执行以下命令：

[wangshibing@yf-oped-dev02.yf01.baidu.com test]$ go test -test.bench=".*"

PASS

BenchmarkAdd 2000000000 1.25 ns/op

ok _/home/users/wangshibing/go-project/test 2.639s

测试的结果是：PASS（通过），总共执行了2000000000次Add函数，总耗时2.639秒，平均每次循环用时1.25纳秒

go语言异常处理（达心提供）
go语言的设计和规范鼓励开发人员显式地检查错误（与其他语言抛出异常然后catch住是不同的）。这种机制某种程度上使得Go语言的代码冗长重复，但是幸运的是你可以利用一些技巧来把冗长的代码最小化。

go语言的基本错误处理方式是多返回值，典型示例：

file, err = os.Open(filename, os.O_RDONLY, 0)

if err = nil {

return

}

多返回值在很大程度上改善了应用返回值和错误返回值混杂的状况，但这种方式也有较高的使用成本，在任何可能返回错误的地方都要加一句错误判断，例如：

if err : datastore.Get(c, key, record); err = nil {
return &appError{err, "Record not found", 404}
}
if err := viewTemplate.Execute(w, record); err = nil {
return &appError{err, "Can't display record", 500}

}

go语言还提供Panic/Recover机制，主要用于处理不可恢复的异常，比如除零错误、数组越界等。在写一个C++服务时，经常遇到的一个问题是在处理某个或某类请求时发生一些意外情况，可能会导致程序崩溃，即使这类请求只占万分之一，也会影响服务整体的运行。对于一个网络服务来说，并行处理很多请求是最基本的场景，我们希望的是各个请求处理尽量独立，互不影响。goroutine为我们提供了并行处理的能力，而panic/recover可以用来容忍单个goroutine内发生的异常。

panic()用来抛出异常，recover()用来处理panic()抛出的异常，recover()需要跟defer配合使用。defer的作用是指定在函数返回之前一定会执行的函数。recover()只有在发生过panic()后调用才会返回Error，否则返回nil。

我们来看下面的例子：

package main

import "fmt"

import "time"

func ready(w string, sec int) {

defer func() {

if err := recover(); err = nil {

fmt.Println("failed:", err)

}

}()

time.Sleep(time.Duration(sec) * time.Second)

if w = "impossible!" {

panic("impossible value")

return

}

fmt.Println(w, "is ready!")

}

func main() {

go ready("impossible!", 1)

go ready("Tea", 2)

fmt.Println("I'm waiting...")

time.Sleep(3 * time.Second)

}

执行这个程序，输出结果为：

I'm waiting...

failed: impossible value

Tea is ready!

如果没有defer以及recover这段处理，则程序在第一个goroutine处理过程中就会异常退出。

panic/recover这种机制也可以用于处理复杂逻辑的错误统一出口，即处理过程中发生任何异常都抛出panic，然后在入口处统一调用defer处理，并且利用defer的特性，可以设定返回值。我们来看regexp 包里一个理想化的节选。

// Compile returns a parsed representation of the regular expression.

func Compile(str string) (regexp *Regexp, err os.Error) {

regexp = new(Regexp)

// doParse will panic if there is a parse error.

defer func() {

if e : recover(); e = nil {

regexp = nil // Clear return value.

err = e.(Error) // Will re-panic if not a parse error.

}

}()

return regexp.doParse(str), nil

}

小结一下，go语言提供了错误返回值和类似异常捕获两种错误处理机制，但两种方式的应用场景是有区别的，如果是可预知的错误，建议使用多返回值处理，如果是不可预知或不可恢复的错误，则建议使用recover()机制，避免程序崩溃。还有一个基本的原则，panic限定在一个包内部的错误处理，对外不应该暴露panic，而要在返回值中标记错误。

go语言配置库（宣佑提供）
目前go语言已经有相应的配置载入库，可以方便的载入配置信息，语法与现有的configure类似。由于开发机没有外网权限，可以下载zip格式的源码包自己编译。

goconfig： https://github.com/msbranco/goconfig

假如有配置文件test_config.conf

[DEFAULT]
default_id:1234
[demo]
name_space=argus.demo
key=cpu1
val=12
need_check=true
我们可以在使用类似如下代码获取配置信息

package main

import (

"fmt"

"goconfig"

)

func main() {

c,err := goconfig.LoadConfigFile("test_config.conf");

if err = nil {

fmt.Println("load conf failed");

return;

}

value,_ := c.GetValue("demo", "name_space");

fmt.Println("name_space:", value);

default_id,_ := c.Int("DEFAULT", "default_id");

fmt.Println("default_id:", default_id);

need_check := c.MustBool("demo", "need_check");

if (need_check) {

fmt.Println("need_check:", need_check);

}

c.SetValue("demo", "val", "3");

goconfig.SaveConfigFile(c, "test_config_result.conf");

return;

}

运行结果：

name_space: argus.demo

default_id: 1234

need_check: true

go语言日志库（宣佑提供）
同log4cxx以及log4j等库一样，go语言也存在一个log4go的日志库来帮助我们打印log信息。

log4go： https://github.com/alecthomas/log4go

log4go的使用非常简单，demo如下：

package main

import (

"time"

"fmt"

)

import log "log4go"

var test_int int;

func main() {

test_int = 1;

fmt.Println(test_int);

// 这里是设置日志文件及其日志级别的关键,注意不同的日志级别选择不同的name

log.AddFilter("file", log.FINE, log.NewFileLogWriter("test.log", false))

log.AddFilter("wf_file", log.WARNING, log.NewFileLogWriter("test.log.wf", false))

// 打印不同级别的日志

log.Finest("Everything is created now (notice that I will not be printing to the file)")

log.Info("The time is now: %s", time.Now().Format("15:04:05 MST 2006/01/02"))

log.Critical("Time to close out!")

// Close the log

log.Close()

}