使用 gdb 工具调试 Go

排除应用程序故障是比较复杂的，特别是处理像 Go 这样的高并发语言。它更容易在具体位置使用 print 打印语句来确定程序状态，但是这个方法很难根据条件发展去动态响应你的代码。

成都创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站设计、网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的轮台网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

调试器提供了一个强大得令人难以置信的故障排除机制。添加排除故障的代码可以巧妙地影响到应用程序该如何运行。调试器可以给正在迷茫的你更精确的看法。

[[145285]]

已经有许多 Go 的调试器存在了，其中一些调试器的不好之处是通过在编译时注入代码来提供一个交互终端。gdb 调试器则允许你调试已经编译好的二进制文件，只要他们已经与 debug 信息连接，并不用修改源代码。这是个相当不错的特性，因此你可以从你的部署环境中取一个产品然后灵活地调试它。你可以从Golang 官方文档中阅读更多关于 gdb 的信息，那么这篇指南将简单讲解使用 gdb 调试器来调试 Go 应用程序的基本用法。

这儿会宣布一些 gdb 的***更新，最特别的是替换 -> 操作为 . 符号来访问对象属性。记住这儿可能在gdb 和 Go 版本中有细微改变。本篇指南基于 gdb 7.7.1和go 1.5beta2。

开始 gdb 调试

为了实验 gdb 我使用了一个测试程序，完整的源代码可以在gdb_sandbox_on_Github上查看。让我们从一个非常简单的程序开始吧：

 
 
      
  
  1. package main 
    2.   
  
  2.  
    3.   
  
  3. import (  
    4.   
  
  4.     "fmt"  
    5.   
  
  5. ) 
    6.   
  
  6.  
    7.   
  
  7. func main() {  
    8.   
  
  8.     for i := 0; i < 5; i++ { 
    9.   
  
  9.         fmt.Println("looping")  
    10.   
  
  10.     }  
    11.   
  
  11.     fmt.Println("Done")  
    12.   
  
  12. } 
    13.

我们可以运行这段代码并看到它输出内容的和我们想象的一样：

 
 
      
  
  1. $ go run main.go 
    2.   
  
  2. looping 
    3.   
  
  3. looping 
    4.   
  
  4. looping 
    5.   
  
  5. looping 
    6.   
  
  6. looping 
    7.   
  
  7. Done 
    8.

我们来调试这个程序吧。首先，使用 go build 编译成二进制文件，接着使用这个二进制文件的路径做为参数运行 gdb。根据你的设定，你也可以使用 source命令来获取 Go 运行时（Go runtime）的支持。现在我们已经在 gdb 的命令行中了，我们可以在运行我们的二进制文件前为它设置断点。

 
 
      
  
  1. $ go build -gcflags "-N -l" -o gdb_sandbox main.go  
    2.   
  
  2. $ ls 
    3.   
  
  3. gdb_sandbox  main.go  README.md 
    4.   
  
  4. $ gdb gdb_sandbox 
    5.   
  
  5. .... 
    6.   
  
  6. (gdb) source /usr/local/src/go/src/runtime/runtime-gdb.py 
    7.   
  
  7. Loading Go Runtime support. 
    8.

***关，我们在 for 循环里面设置一个断点（b）来查看执行每次循环时我们的代码会各有什么状态。我们可以使用print（p）命令来检查当前内容的一个变量，还有 list（l）和 backtrace（bt）命令查看当前步骤周围的代码。程序运行时可以使用 next（n）执行下一步或者使用 breakpoint（c）执行到下一个断点。

 
 
      
  
  1. (gdb) b main.go:9  
    2.   
  
  2. Breakpoint 1 at 0x400d35: file /home/bfosberry/workspace/gdb_sandbox/main.go, line 9.  
    3.   
  
  3. (gdb) run  
    4.   
  
  4. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox Breakpoint 1, main.main () at  
    5.   
  
  5. /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:9  
    6.   
  
  6. 9         fmt.Println("looping")  
    7.   
  
  7. (gdb) l  
    8.   
  
  8. 4         "fmt"  
    9.   
  
  9. 5         )  
    10.   
  
  10. 6   
    11.   
  
  11. 7 func main() { 
    12.   
  
  12. 8         for i := 0; i < 5; i++ {  
    13.   
  
  13. 9         fmt.Println("looping")  
    14.   
  
  14. 10        }`  
    15.   
  
  15. 11        fmt.Println("Done")  
    16.   
  
  16. 12 }  
    17.   
  
  17. (gdb) p i  
    18.   
  
  18. $1 = 0  
    19.   
  
  19. (gdb) n  
    20.   
  
  20. looping  
    21.   
  
  21. Breakpoint 1, main.main () at  
    22.   
  
  22. /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:9  
    23.   
  
  23. 9        fmt.Println("looping")  
    24.   
  
  24. (gdb) p i  
    25.   
  
  25. $2 = 1  
    26.   
  
  26. (gdb) bt 
    27.   
  
  27. # 0 main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:9 
    28.

我们的断点可以设置在关联文件的行号中、GOPATH里的文件的行号或一个包里的函数。如下也是一个有效的断点：

 
 
      
  
  1. (gdb) b github.com/bfosberry/gdb_sandbox/main.go:9 
    2.   
  
  2. (gdb) b 'main.main' 
    3.

Structs

我们可以用稍微复杂一点的代码来实例演示如何调试。我们将使用f函数生成一个简单的pair，x和y，当x相等时y=f(x)，否则=x。

 
 
      
  
  1. type pair struct {  
    2.   
  
  2.     x int  
    3.   
  
  3.     y int  
    4.   
  
  4. } 
    5.   
  
  5.  
    6.   
  
  6. func handleNumber(i int) *pair {  
    7.   
  
  7.     val := i  
    8.   
  
  8.     if i%2 == 0 {  
    9.   
  
  9.         val = f(i)  
    10.   
  
  10.     }  
    11.   
  
  11.     return &pair{  
    12.   
  
  12.        x: i,  
    13.   
  
  13.        y: val,  
    14.   
  
  14.     }  
    15.   
  
  15. } 
    16.   
  
  16.  
    17.   
  
  17. func f(int x) int {  
    18.   
  
  18.     return x*x + x  
    19.   
  
  19. } 
    20.

也可以在循环中改变代码来访问这些新函数。

 
 
      
  
  1. p := handleNumber(i) 
    2.   
  
  2. fmt.Printf("%+v/n", p) 
    3.   
  
  3. fmt.Println("looping") 
    4.

因为我们需要调试的是变量 y。我们可以在y被设置的地方放置断点然后单步执行。可以使用 info args查看函数的参数，在 bt之前可以返回当前回溯。

 
 
      
  
  1. (gdb) b 'main.f'  
    2.   
  
  2. (gdb) run  
    3.   
  
  3. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox 
    4.   
  
  4.  
    5.   
  
  5. Breakpoint 1, main.f (x=0, ~anon1=833492132160)  
    6.   
  
  6.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:33  
    7.   
  
  7. 33       return x*x + x  
    8.   
  
  8. (gdb) info args  
    9.   
  
  9. x = 0  
    10.   
  
  10. (gdb) continue  
    11.   
  
  11. Breakpoint 1, main.f (x=0, ~anon1=833492132160)  
    12.   
  
  12.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:33  
    13.   
  
  13. 33       return x*x + x  
    14.   
  
  14. (gdb) info args  
    15.   
  
  15. x = 2  
    16.   
  
  16. (gdb) bt 
    17.   
  
  17. #0 main.f (x=2, ~anon1=1)  
    18.   
  
  18.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:33 
    19.   
  
  19. #1 0x0000000000400f0e in main.handleNumber (i=2, ~anon1=0x1) 
    20.   
  
  20.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:24 
    21.   
  
  21. #2 0x0000000000400c47 in main.main () 
    22.   
  
  22.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:14 
    23.

因为我们在变量 y 是在函数 f 中被设定的这样一个条件下，我们可以跳到这个函数的上下文并检查堆区的代码。应用运行时我们可以在一个更高的层次上设置断点并检查其状态。

 
 
      
  
  1. (gdb) b main.go:26  
    2.   
  
  2. Breakpoint 2 at 0x400f22: file  
    3.   
  
  3. /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 26.  
    4.   
  
  4. (gdb) continue  
    5.   
  
  5. Continuing. 
    6.   
  
  6. Breakpoint 2, main.handleNumber (i=2, ~anon1=0x1)  
    7.   
  
  7.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:28  
    8.   
  
  8. 28             y: val,  
    9.   
  
  9. (gdb) l  
    10.   
  
  10. 23         if i%2 == 0 {  
    11.   
  
  11. 24             val = f(i)  
    12.   
  
  12. 25         }  
    13.   
  
  13. 26         return &pair{  
    14.   
  
  14. 27             x: i,  
    15.   
  
  15. 28             y: val,  
    16.   
  
  16. 29         }  
    17.   
  
  17. 30     }  
    18.   
  
  18. 31   
    19.   
  
  19. 32 func f(x int) int {  
    20.   
  
  20. (gdb) p val  
    21.   
  
  21. $1 = 6  
    22.   
  
  22. (gdb) p i  
    23.   
  
  23. $2 = 2 
    24.

如果我们在这个断点处继续住下走我们将越过在这个函数中的断点1，而且将立即触发在 HandleNumer 函数中的断点，因为函数 f 只是对变量 i 每隔一次才执行。我们可以通过暂时使断点 2不工作来避免这种情况的发生。

 
 
      
  
  1. (gdb) disable breakpoint 2  
    2.   
  
  2. (gdb) continue  
    3.   
  
  3. Continuing.  
    4.   
  
  4. &{x:2 y:6}  
    5.   
  
  5. looping  
    6.   
  
  6. &{x:3 y:3}  
    7.   
  
  7. looping  
    8.   
  
  8. [New LWP 15200]  
    9.   
  
  9. [Switching to LWP 15200] 
    10.   
  
  10. Breakpoint 1, main.f (x=4, ~anon1=1)  
    11.   
  
  11.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:33  
    12.   
  
  12. 33         return x*x + x  
    13.   
  
  13. (gdb) 
    14.

我们也可以分别使用 clear 和 delete breakpoint NUMBER 来清除和删除断点。动态产生和系住断点，我们可以有效地在应用流中来回移动。

Slices and Pointers

上例程序太简单了，只用到了整数型和字符串，所以我们将写一个稍微复杂一点的。首先添加一个slice（切片类型）的指针到 main 函数，并保存生成的 pair，我们后面将用到它。

 
 
      
  
  1. var pairs []*pair 
    2.   
  
  2. for i := 0; i < 10; i++ { 
    3.   
  
  3.     p := handleNumber(i) 
    4.   
  
  4.     fmt.Printf("%+v/n", p) 
    5.   
  
  5.     pairs = append(pairs, p) 
    6.   
  
  6.     fmt.Println("looping") 
    7.   
  
  7.     } 
    8.

现在我们来检查生成出来的 slice 或 pairs，首先我们用转换成数组来看一下这个 slice。因为 handleNumber 返回的是一个 *pair 类型，我们需要引用这个指针来访问 struct（结构）的属性。

 
 
      
  
  1. (gdb) b main.go:18  
    2.   
  
  2. Breakpoint 1 at 0x400e14: file /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 18.  
    3.   
  
  3. (gdb) run  
    4.   
  
  4. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox &{x:0 y:0} 
    5.   
  
  5.  
    6.   
  
  6. Breakpoint 1, main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:18  
    7.   
  
  7. 18         fmt.Println("looping")  
    8.   
  
  8. (gdb) p pairs  
    9.   
  
  9. $1 = []*main.pair = {0xc82000a3a0}  
    10.   
  
  10. (gdb) p pairs[0]  
    11.   
  
  11. Structure has no component named operator[].  
    12.   
  
  12. (gdb) p pairs.array  
    13.   
  
  13. $2 = (struct main.pair **) 0xc820030028  
    14.   
  
  14. (gdb) p pairs.array[0]  
    15.   
  
  15. $3 = (struct main.pair *) 0xc82000a3a0  
    16.   
  
  16. (gdb) p *pairs.array[0]  
    17.   
  
  17. $4 = {x = 0, y = 0}  
    18.   
  
  18. (gdb) p (*pairs.array[0]).x  
    19.   
  
  19. $5 = 0  
    20.   
  
  20. (gdb) p (*pairs.array[0]).y  
    21.   
  
  21. $6 = 0  
    22.   
  
  22. (gdb) continue  
    23.   
  
  23. Continuing.  
    24.   
  
  24. looping  
    25.   
  
  25. &{x:1 y:1} 
    26.   
  
  26.  
    27.   
  
  27. Breakpoint 1, main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:18  
    28.   
  
  28. 18         fmt.Println("looping")  
    29.   
  
  29. (gdb) p (pairs.array[1][5]).y  
    30.   
  
  30. $7 = 1  
    31.   
  
  31. (gdb) continue  
    32.   
  
  32. Continuing.  
    33.   
  
  33. looping  
    34.   
  
  34. &{x:2 y:6} 
    35.   
  
  35.  
    36.   
  
  36. Breakpoint 1, main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:18  
    37.   
  
  37. 18         fmt.Println("looping")  
    38.   
  
  38. (gdb) p (pairs.array[2][6]).y  
    39.   
  
  39. $8 = 6  
    40.   
  
  40. (gdb) 
    41.

你会发现这里 gdb 并不确定 pairs 是一个 slice 类型，我们不能直接访问它的属性，为了访问它的成员我们需要使用 pairs.array 来转换成数组，然后我们就可以检查 slice 的 length（长度）和 capacity（容量）：

 
 
      
  
  1. (gdb) p $len(pairs) 
    2.   
  
  2. $12 = 3 
    3.   
  
  3. (gdb) p $cap(pairs) 
    4.   
  
  4. $13 = 4 
    5.

这时我们可以让它循环几次，并透过这个 slice 不用的成员方法监听增加的 x 和 y 的值，要注意的是，这里的 struct 属性可以通过指针访问，所以 p pairs.array[2].y 一样可行。

Goroutines

现在我们已经可以访问 struct 和 slice 了，下面再来更加复杂一点的程序吧。让我们添加一些goroutines 到 mian 函数，并行处理每一个数字，返回的结果存入信道（chan）中：

 
 
      
  
  1.     pairs := []*pair{} 
    2.   
  
  2.     pairChan := make(chan *pair) 
    3.   
  
  3.     wg := sync.WaitGroup{} 
    4.   
  
  4.         for i := 0; i < 10; i++ { 
    5.   
  
  5.           wg.Add(1) 
    6.   
  
  6.           go func(val int) { 
    7.   
  
  7.             p := handleNumber(val) 
    8.   
  
  8.             fmt.Printf("%+v/n", p) 
    9.   
  
  9.             pairChan <- p 
    10.   
  
  10.             wg.Done() 
    11.   
  
  11.             }(i) 
    12.   
  
  12.     } 
    13.   
  
  13.     go func() { 
    14.   
  
  14.             for p := range pairChan { 
    15.   
  
  15.               pairs = append(pairs, p) 
    16.   
  
  16.             } 
    17.   
  
  17.     }() 
    18.   
  
  18.     wg.Wait() 
    19.   
  
  19.     close(pairChan) 
    20.   
  
  20.  
    21.   
  
  21. 如果我等待 WaitGroup 执行完毕再检查 pairs slice 的结果，我们可以预期到内容是完全相同的，虽然它的排序可能有些出入。gdb 真正的威力来自于它可以在 goroutines 正在运行时进行检查： 
    22.   
  
  22.  
    23.   
  
  23. (gdb) b main.go:43  
    24.   
  
  24. Breakpoint 1 at 0x400f7f: file /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 43.  
    25.   
  
  25. (gdb) run  
    26.   
  
  26. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox 
    27.   
  
  27.  
    28.   
  
  28. Breakpoint 1, main.handleNumber (i=0, ~r1=0x0)  
    29.   
  
  29.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:43  
    30.   
  
  30. 43         y: val,  
    31.   
  
  31. (gdb) l  
    32.   
  
  32. 38     if i%2 == 0 {  
    33.   
  
  33. 39         val = f(i)  
    34.   
  
  34. 40     }  
    35.   
  
  35. 41     return &pair{  
    36.   
  
  36. 42         x: i,  
    37.   
  
  37. 43         y: val,  
    38.   
  
  38. 44     }  
    39.   
  
  39. 45 }  
    40.   
  
  40. 46   
    41.   
  
  41. 47 func f(x int) int {  
    42.   
  
  42. (gdb) info args  
    43.   
  
  43. i = 0  
    44.   
  
  44. ~r1 = 0x0  
    45.   
  
  45. (gdb) p val  
    46.   
  
  46. $1 = 0 
    47.

你会发现我们在 goroutine 要执行的代码段中放置了一个断点，从这里我们可以检查到局部变量，和进程中的其它 goroutines：

 
 
      
  
  1. (gdb) info goroutines  
    2.   
  
  2.   1 waiting runtime.gopark  
    3.   
  
  3.   2 waiting runtime.gopark  
    4.   
  
  4.   3 waiting runtime.gopark  
    5.   
  
  5.   4 waiting runtime.gopark  
    6.   
  
  6. * 5 running main.main.func1  
    7.   
  
  7.   6 runnable main.main.func1  
    8.   
  
  8.   7 runnable main.main.func1  
    9.   
  
  9.   8 runnable main.main.func1  
    10.   
  
  10.   9 runnable main.main.func1  
    11.   
  
  11. * 10 running main.main.func1  
    12.   
  
  12.   11 runnable main.main.func1  
    13.   
  
  13.   12 runnable main.main.func1  
    14.   
  
  14.   13 runnable main.main.func1  
    15.   
  
  15.   14 runnable main.main.func1  
    16.   
  
  16.   15 waiting runtime.gopark  
    17.   
  
  17. (gdb) goroutine 11 bt 
    18.   
  
  18. #0 main.main.func1 (val=6, pairChan=0xc82001a180, &wg=0xc82000a3a0) 
    19.   
  
  19.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:19 
    20.   
  
  20. #1 0x0000000000454991 in runtime.goexit () at /usr/local/go/src/runtime/asm_amd64.s:1696 
    21.   
  
  21. #2 0x0000000000000006 in ?? () 
    22.   
  
  22. #3 0x000000c82001a180 in ?? () 
    23.   
  
  23. #4 0x000000c82000a3a0 in ?? () 
    24.   
  
  24. #5 0x0000000000000000 in ?? () 
    25.   
  
  25. (gdb) goroutine 11 l  
    26.   
  
  26. 48         return x*x + x  
    27.   
  
  27. 49     }  
    28.   
  
  28. (gdb) goroutine 11 info args  
    29.   
  
  29. val = 6  
    30.   
  
  30. pairChan = 0xc82001a180  
    31.   
  
  31. &wg = 0xc82000a3a0  
    32.   
  
  32. (gdb) goroutine 11 p val  
    33.   
  
  33. $2 = 6 
    34.

在这里我们做的***件事就是列出所有正在运行的 goroutine，并确定我们正在处理的那一个。然后我们可以看到一些回溯，并发送任何调试命令到 goroutine。这个回溯和列表清单并不太准确，如何让回溯更准确，goroutine 上的 info args显示了我们的局部变量，以及主函数中的可用变量，goroutine 函数之外的使用前缀&。

结论

当调试应用时，gdb 的强大令人难以置信。但它仍然是一个相当新的事物，并不是所有的地方工作地都很***。使用***的稳定版 gdb，go 1.5 beta2，有不少地方有突破：

Interfaces

根据 go 博客上的文章, go 的 interfaces 应该已经支持了，这允许在 gdb中动态的投影其基类型。这应该算一个突破。

Interface{} 类型

目前没有办法转换 interface{} 为它的类型。

列出 goroutine 的不同点

在其他 goroutine 中列出周边代码会导致一些行数的漂移，最终导致 gdb 认为当前的行数超出文件范围并抛出一个错误：

 
 
      
  
  1. (gdb) info goroutines  
    2.   
  
  2.   1 waiting runtime.gopark  
    3.   
  
  3.   2 waiting runtime.gopark  
    4.   
  
  4.   3 waiting runtime.gopark  
    5.   
  
  5.   4 waiting runtime.gopark  
    6.   
  
  6. * 5 running main.main.func1  
    7.   
  
  7.   6 runnable main.main.func1  
    8.   
  
  8.   7 runnable main.main.func1  
    9.   
  
  9.   8 runnable main.main.func1  
    10.   
  
  10.   9 runnable main.main.func1  
    11.   
  
  11. * 10 running main.main.func1  
    12.   
  
  12.   11 runnable main.main.func1  
    13.   
  
  13.   12 runnable main.main.func1  
    14.   
  
  14.   13 runnable main.main.func1  
    15.   
  
  15.   14 runnable main.main.func1  
    16.   
  
  16.   15 waiting runtime.gopark  
    17.   
  
  17. (gdb) goroutine 11 bt 
    18.   
  
  18. #0 main.main.func1 (val=6, pairChan=0xc82001a180, &wg=0xc82000a3a0) 
    19.   
  
  19.     at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go:19 
    20.   
  
  20. #1 0x0000000000454991 in runtime.goexit () at /usr/local/go/src/runtime/asm_amd64.s:1696 
    21.   
  
  21. #2 0x0000000000000006 in ?? () 
    22.   
  
  22. #3 0x000000c82001a180 in ?? () 
    23.   
  
  23. #4 0x000000c82000a3a0 in ?? () 
    24.   
  
  24. #5 0x0000000000000000 in ?? () 
    25.   
  
  25. (gdb) goroutine 11 l  
    26.   
  
  26. 48         return x*x + x  
    27.   
  
  27. 49     }  
    28.   
  
  28. (gdb) goroutine 11 l  
    29.   
  
  29. Python Exception  Line number 50 out of range; /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go has 49 lines.:  
    30.   
  
  30. Error occurred in Python command: Line number 50 out of range; /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go has 49 lines. 
    31.

Goroutine 调试还不稳定

处理 goroutines 往往不稳定；我遇到过执行简单命令产生错误的情况。现阶段你应该做好处理类似问题的准备。

gdb 支持 Go 的配置非常麻烦

运行 gdb 支持 Go 调试的配置非常麻烦，获取正确的路径结合与构建 flags，还有 gdb 自动加载功能好像都不能正常的工作。首先，通过一个 gdb 初始化文件加载 Go 运行时支持就会产生初始化错误。这就需要手动通过一个源命令去加载，调试 shell 需要像指南里面描述的那样去进行初始化。

我什么时候该使用一个调试器?

所以什么情况下使用 gdb 更有用？使用 print 语言和调试代码是更有针对性的方法。

  • 当不适合修改代码的时候

  • 当调试一个问题，但是不知道源头，动态断点或许更有效

  • 当包含许多 goroutines 时，暂停然后审查程序状态会更好

“Debugging #golang with gdb” – via @codeship —— from Tweet

分享名称：使用 gdb 工具调试 Go
当前地址：http://www.hantingmc.com/qtweb/news31/58131.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

域名注册知识

各行业网站

蓬溪网站建设　　 　网站空间　　 　高防机房　　 　建站定制开发　　 　整合营销　　 　成都网站改版　　 　四川绵阳主机托管　　 　四川内江电信机房　　 　成都名片印刷厂　　 　固迪佳新材料　　 　青羊区雕琢时光　　 　班戈纳美网站　　 　广安园林景观设计　　 　微信小程序　　 　王君美油画　　 　自贡主机托管　　 　梓潼网站设计　　 　四川柴油发电机　　 　梓潼网站制作公司　　 　西云服务器托管