当前位置： 首页 > article >正文

第 23 章 -Golang 调试技巧

article 2024/11/23 0:53:02

在软件开发过程中，调试是一项非常重要的技能，它帮助开发者定位并修复代码中的错误。这里，我将介绍两种常用的调试工具：GNU Debugger (gdb) 和 Delve (dlv)，它们分别用于 C/C++ 和 Go 语言的程序调试。

使用 gdb 进行调试

示例程序 (C++)

假设我们有一个简单的 C++ 程序 main.cpp：

#include <iostream>

int add(int x, int y) {
    return x + y;
}

int main() {
    int a = 5;
    int b = 10;
    int c = add(a, b);
    std::cout << "The sum of " << a << " and " << b << " is " << c << std::endl;
    return 0;
}

编译该程序时，需要加上 -g 参数以包含调试信息：

g++ -g main.cpp -o main

启动 gdb 并加载程序：

gdb ./main

在 gdb 中设置断点，并运行程序：

(gdb) break add
Breakpoint 1 at 0x4005b6: file main.cpp, line 4.
(gdb) run
Starting program: /path/to/main

当程序执行到 add 函数时会停下来，此时可以查看变量值、单步执行等：

(gdb) print a
$1 = 5
(gdb) print b
$2 = 10
(gdb) step

继续执行直到程序结束或手动停止：

(gdb) continue

使用 Delve 进行调试

示例程序 (Go)

假设我们有一个简单的 Go 程序 main.go：

package main

import "fmt"

func add(x int, y int) int {
    return x + y
}

func main() {
    a := 5
    b := 10
    c := add(a, b)
    fmt.Printf("The sum of %d and %d is %d\n", a, b, c)
}

编译该程序时，不需要特别的参数来包含调试信息，因为 Go 编译器默认会包含这些信息：

go build -o main main.go

启动 Delve 并加载程序：

dlv exec ./main

或者直接使用 Delve 运行程序并自动暂停：

dlv debug main.go

在 Delve 中设置断点，并开始调试：

(dlv) break add
Breakpoint 1 set at 0x4f9f7e for main.add() ./main.go:5
(dlv) continue
> main.add() ./main.go:5 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)

查看变量值，单步执行：

(dlv) print a
5
(dlv) print b
10
(dlv) step
> main.main() ./main.go:10 (PC: 0x4f9fa6)

继续执行直到程序结束或手动停止：

(dlv) continue
The sum of 5 and 10 is 15
Process 12345 has exited with status 0

以上是使用 gdb 和 Delve 进行基本调试的例子。实际使用中，这两种工具都提供了丰富的命令集来满足更复杂的调试需求，如条件断点、观察点、多线程调试等。掌握这些工具能够极大地提高开发效率和代码质量。

当然，我们可以深入探讨如何使用 Go 语言进行调试，特别是通过 Delve (dlv) 这个强大的调试工具。Delve 是一个专门为 Go 语言设计的调试器，它支持多种调试操作，包括设置断点、单步执行、查看变量值、调用栈检查等。

安装 Delve

首先，确保你的环境中已经安装了 Delve。可以通过以下命令安装：

go install github.com/go-delve/delve/cmd/dlv@latest

安装完成后，确保 dlv 命令可以在你的系统路径中找到。

示例程序

假设我们有如下 Go 程序 main.go：

package main

import (
	"fmt"
)

func add(x int, y int) int {
	return x + y
}

func main() {
	a := 5
	b := 10
	c := add(a, b)
	fmt.Printf("The sum of %d and %d is %d\n", a, b, c)
}

使用 Delve 调试

1. 启动 Delve

你可以选择使用 dlv exec 或 dlv debug 来启动 Delve。dlv exec 适用于已经编译好的二进制文件，而 dlv debug 可以直接从源代码开始调试。

使用 dlv exec

先编译程序：

go build -o main main.go

然后使用 Delve 启动调试：

dlv exec ./main
使用 dlv debug

直接从源代码启动调试：

dlv debug main.go
2. 设置断点

在 Delve 中，可以使用 break 命令设置断点。例如，在 add 函数处设置断点：

(dlv) break add
Breakpoint 1 set at 0x4f9f7e for main.add() ./main.go:5
3. 开始调试

使用 continue 命令开始执行程序：

(dlv) continue

当程序执行到断点时，Delve 会暂停执行，并显示当前的执行位置：

> main.add() ./main.go:5 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)
4. 查看变量值

在断点处，可以使用 print 或 p 命令查看变量的值：

(dlv) print a
5
(dlv) print b
10
5. 单步执行

使用 step 或 next 命令单步执行代码：

  • step 会进入函数内部。
  • next 会在当前函数内单步执行，不会进入函数内部。
(dlv) step
> main.add() ./main.go:6 (PC: 0x4f9f81)
6. 继续执行

使用 continue 命令继续执行程序，直到下一个断点或程序结束：

(dlv) continue
The sum of 5 and 10 is 15
Process 12345 has exited with status 0

其他常用命令

  • list (l): 显示当前执行位置附近的代码。
  • args: 显示当前函数的参数。
  • locals: 显示当前作用域内的局部变量。
  • goroutines (gr): 显示当前运行的所有 Goroutine。
  • stack (bt): 显示当前的调用栈。
  • clear: 删除指定的断点。
  • quit (q): 退出 Delve。

示例：复杂场景

假设我们有一个更复杂的程序，涉及多个 Goroutine 和并发操作：

package main

import (
	"fmt"
	"time"
)

func worker(id int, done chan bool) {
	fmt.Printf("Worker %d starting\n", id)
	time.Sleep(time.Second)
	fmt.Printf("Worker %d finished\n", id)
	done <- true
}

func main() {
	done := make(chan bool, 3)
	for i := 1; i <= 3; i++ {
		go worker(i, done)
	}
	for i := 1; i <= 3; i++ {
		<-done
	}
	fmt.Println("All workers finished")
}
调试步骤

  1. 启动 Delve：

    dlv debug main.go

  2. 在 worker 函数处设置断点：

    (dlv) break worker
Breakpoint 1 set at 0x4f9f7e for main.worker() ./main.go:7

  3. 开始调试：

    (dlv) continue

  4. 当程序暂停在 worker 函数时，查看当前 Goroutine：

    (dlv) goroutines
* Goroutine 1 - User: /path/to/main.go:15 main.main (0x4f9f7e)
  Goroutine 2 - User: /path/to/main.go:7 main.worker (0x4f9f7e)
  Goroutine 3 - User: /path/to/main.go:7 main.worker (0x4f9f7e)
  Goroutine 4 - User: /path/to/main.go:7 main.worker (0x4f9f7e)

  5. 切换到特定的 Goroutine：

    (dlv) goroutine 2
Switched to goroutine 2
> main.worker() ./main.go:7 (PC: 0x4f9f7e)

  6. 继续执行：

    (dlv) continue

通过这些步骤，你可以更深入地理解和调试复杂的 Go 程序。Delve 提供了丰富的功能，可以帮助你在开发过程中更高效地解决问题。

当然，我们可以进一步深入探讨一些更高级的调试技巧和场景，以便更好地利用 Delve 进行 Go 语言的调试。

高级调试技巧

1. 条件断点

有时候，你可能希望在某个特定条件下才触发断点。Delve 支持设置条件断点，这可以通过 break 命令的 -cond 选项来实现。

假设我们有一个循环，希望在某个特定的迭代次数上暂停：

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ {
		fmt.Printf("Iteration %d\n", i)
	}
}

设置一个条件断点，当 i == 5 时暂停：

(dlv) break main.main -cond i == 5
Breakpoint 1 set at 0x4f9f7e for main.main() ./main.go:6

开始调试：

(dlv) continue
Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4
> main.main() ./main.go:6 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)
2. 观察点（Watchpoints）

观察点允许你监视某个变量的变化。当变量的值发生变化时，程序会暂停执行。

假设我们有一个变量 count，我们希望在它的值发生变化时暂停：

package main

import (
	"fmt"
)

func main() {
	count := 0
	for i := 0; i < 10; i++ {
		count += i
		fmt.Printf("Count: %d\n", count)
	}
}

设置一个观察点：

(dlv) watch count

开始调试：

(dlv) continue
Count: 0
Count: 1
> main.main() ./main.go:8 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)
3. 调用栈检查

在调试过程中，查看调用栈可以帮助你理解程序的执行流程。使用 stack 或 bt 命令可以查看当前的调用栈。

假设我们有一个递归函数：

package main

import (
	"fmt"
)

func factorial(n int) int {
	if n == 0 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	result := factorial(5)
	fmt.Printf("Factorial of 5 is %d\n", result)
}

在 factorial 函数处设置断点：

(dlv) break factorial
Breakpoint 1 set at 0x4f9f7e for main.factorial() ./main.go:7

开始调试：

(dlv) continue
> main.factorial() ./main.go:7 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)

查看调用栈：

(dlv) stack
#0  main.factorial (n=5) at ./main.go:7
#1  main.main () at ./main.go:12
4. 修改变量值

在调试过程中，有时需要修改变量的值以测试不同的情况。使用 set 命令可以修改变量的值。

假设我们有一个简单的程序：

package main

import (
	"fmt"
)

func main() {
	a := 5
	b := 10
	c := a + b
	fmt.Printf("The sum of %d and %d is %d\n", a, b, c)
}

在 main 函数处设置断点：

(dlv) break main.main
Breakpoint 1 set at 0x4f9f7e for main.main() ./main.go:6

开始调试：

(dlv) continue
> main.main() ./main.go:6 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)

修改变量 a 的值：

(dlv) set a = 15
(dlv) print a
15

继续执行：

(dlv) continue
The sum of 15 and 10 is 25
Process 12345 has exited with status 0

调试多文件项目

对于多文件项目，Delve 也可以很好地支持。假设我们有一个项目结构如下：

myproject/
├── main.go
└── utils/
    └── helpers.go

main.go:

package main

import (
	"fmt"
	"myproject/utils"
)

func main() {
	a := 5
	b := 10
	c := utils.Add(a, b)
	fmt.Printf("The sum of %d and %d is %d\n", a, b, c)
}

utils/helpers.go:

package utils

func Add(x int, y int) int {
	return x + y
}

启动 Delve：

cd myproject
dlv debug

在 Add 函数处设置断点：

(dlv) break utils.Add
Breakpoint 1 set at 0x4f9f7e for utils.Add() ./utils/helpers.go:3

开始调试：

(dlv) continue
> utils.Add() ./utils/helpers.go:3 (hits goroutine(1):1 total:1) (PC: 0x4f9f7e)

查看变量值：

(dlv) print x
5
(dlv) print y
10

继续执行：

(dlv) continue
The sum of 5 and 10 is 15
Process 12345 has exited with status 0

总结

通过这些高级调试技巧，你可以更灵活地使用 Delve 来调试复杂的 Go 项目。无论是条件断点、观察点、调用栈检查还是修改变量值，Delve 都提供了强大的功能来帮助你快速定位和解决问题。希望这些示例能帮助你在实际开发中更加高效地进行调试。

当然，我们可以继续深入探讨更多高级调试技巧和实用场景，以帮助你更全面地掌握 Delve 的使用方法。

5. 调试远程服务

在实际开发中，你可能需要调试运行在远程服务器上的服务。Delve 支持远程调试，这可以通过以下步骤实现：

步骤 1: 在远程服务器上启动 Delve 监听器

首先，确保远程服务器上已经安装了 Delve。然后，使用 dlv exec 命令启动监听器：

dlv --listen=:2345 --headless=true --api-version=2 exec /path/to/your/binary
  • --listen=:2345: 指定 Delve 监听的端口。
  • --headless=true: 以无头模式运行，这意味着 Delve 不会立即启动调试会话，而是等待客户端连接。
  • --api-version=2: 指定 API 版本。
步骤 2: 在本地连接到远程 Delve 服务器

在本地机器上，使用 dlv connect 命令连接到远程 Delve 服务器：

dlv connect remote-server-ip:2345
步骤 3: 设置断点并开始调试

连接成功后，你可以在远程服务上设置断点并开始调试：

(dlv) break main.main
Breakpoint 1 set at 0x4f9f7e for main.main() ./main.go:6
(dlv) continue

6. 调试测试代码

Delve 也支持调试测试代码，这对于单元测试和集成测试非常有用。

步骤 1: 编写测试代码

假设我们有一个简单的测试文件 example_test.go：

package main

import (
	"testing"
)

func TestAdd(t *testing.T) {
	a := 5
	b := 10
	expected := 15
	result := add(a, b)
	if result != expected {
		t.Errorf("Expected %d, got %d", expected, result)
	}
}
步骤 2: 使用 Delve 调试测试

使用 dlv test 命令启动调试会话：

dlv test -test.run=TestAdd
步骤 3: 设置断点并开始调试

在 TestAdd 函数处设置断点：

(dlv) break TestAdd
Breakpoint 1 set at 0x4f9f7e for main.TestAdd() ./example_test.go:7
(dlv) continue

7. 调试 HTTP 请求

如果你的应用是一个 HTTP 服务，你可能需要调试 HTTP 请求的处理逻辑。Delve 可以帮助你捕获和调试这些请求。

步骤 1: 编写 HTTP 服务

假设我们有一个简单的 HTTP 服务 server.go：

package main

import (
	"fmt"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, World!")
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}
步骤 2: 使用 Delve 调试 HTTP 服务

启动 Delve 调试会话：

dlv debug server.go
步骤 3: 设置断点并发送请求

在 handler 函数处设置断点：

(dlv) break handler
Breakpoint 1 set at 0x4f9f7e for main.handler() ./server.go:7

打开另一个终端，发送 HTTP 请求：

curl http://localhost:8080

Delve 会暂停在断点处：

(dlv) continue
> main.handler() ./server.go:7 (hits goroutine(6):1 total:1) (PC: 0x4f9f7e)

8. 调试并发问题

并发问题是 Go 语言中常见的问题之一。Delve 提供了一些工具来帮助你调试并发问题。

步骤 1: 编写并发代码

假设我们有一个简单的并发程序 concurrent.go：

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func worker(id int) {
	defer wg.Done()
	fmt.Printf("Worker %d starting\n", id)
	// Simulate some work
	for i := 0; i < 1000000; i++ {
	}
	fmt.Printf("Worker %d finished\n", id)
}

func main() {
	wg.Add(3)
	for i := 1; i <= 3; i++ {
		go worker(i)
	}
	wg.Wait()
	fmt.Println("All workers finished")
}
步骤 2: 使用 Delve 调试并发代码

启动 Delve 调试会话：

dlv debug concurrent.go
步骤 3: 设置断点并开始调试

在 worker 函数处设置断点：

(dlv) break worker
Breakpoint 1 set at 0x4f9f7e for main.worker() ./concurrent.go:7

开始调试：

(dlv) continue

当程序暂停在 worker 函数时，查看当前的 Goroutine：

(dlv) goroutines
* Goroutine 1 - User: /path/to/concurrent.go:15 main.main (0x4f9f7e)
  Goroutine 2 - User: /path/to/concurrent.go:7 main.worker (0x4f9f7e)
  Goroutine 3 - User: /path/to/concurrent.go:7 main.worker (0x4f9f7e)
  Goroutine 4 - User: /path/to/concurrent.go:7 main.worker (0x4f9f7e)

切换到特定的 Goroutine：

(dlv) goroutine 2
Switched to goroutine 2
> main.worker() ./concurrent.go:7 (PC: 0x4f9f7e)

9. 调试性能问题

Delve 也可以帮助你调试性能问题，例如 CPU 和内存使用情况。

步骤 1: 使用 pprof 工具

Go 标准库提供了 pprof 工具，可以帮助你分析性能瓶颈。你可以在代码中启用 pprof：

package main

import (
	"net/http"
	_ "net/http/pprof"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// Simulate some work
		for i := 0; i < 1000000; i++ {
		}
		fmt.Fprintf(w, "Hello, World!")
	})
	http.ListenAndServe(":8080", nil)
}
步骤 2: 使用 Delve 调试

启动 Delve 调试会话：

dlv debug server.go
步骤 3: 发送请求并分析性能

打开另一个终端，发送 HTTP 请求：

curl http://localhost:8080

使用 pprof 工具分析性能：

go tool pprof http://localhost:8080/debug/pprof/profile?seconds=30

总结

通过这些高级调试技巧，你可以更全面地掌握 Delve 的使用方法，从而更有效地调试 Go 语言程序。无论是远程调试、测试代码调试、HTTP 请求调试、并发问题调试还是性能问题调试，Delve 都提供了强大的工具和支持。希望这些示例能帮助你在实际开发中更加高效地进行调试。


http://www.kler.cn/a/405041.html

相关文章：

  • uniapp input限制输入负数,以及保留小数点两位.
  • 计算机网络（12）介质访问控制
  • H.264/H.265播放器EasyPlayer.js视频流媒体播放器关于websocket1006的异常断连
  • yolov5 数据集分享：纯干货
  • 动态规划子数组系列一＞等差数列划分
  • 吴恩达《提示词工程》（Prompt Engineering for Developers）课程详细笔记
  • 爬虫实战：探索XPath爬虫技巧之热榜新闻
  • 基于Springboot + Vue小区物业管理系统(源码+lw+讲解部署+PPT)
  • 【Diffusion分割】CorrDiff：用于脑肿瘤分割的校正扩散模型
  • 【C++】从C到C++
  • C++结构型设计模式所体现面向接口设计的特征和优点
  • tcpdump交叉编译
  • 什么是JavaScript原型链？
  • CosyVoice 上手即用教程
  • 操作系统进程和线程——针对实习面试
  • 华为仓颉语言的技术梗概，底层原理是什么？什么架构，以后会替换JAVA语言了，信创背景下，要不要开始进入仓颉赛道，详细为您剖析仓颉语言
  • 【初阶数据结构篇】双向链表的实现（赋源码）
  • IDEA：2023版远程服务器debug
  • Kafka 3.5 源码导读
  • 网络安全-网络安全基础
  • Redis自动配置-序列化
  • 力扣题解（新增道路查询后的最短距离I）
  • 如何在MindMaster思维导图中制作PPT课件？
  • Spark中的Stage概念
  • 【WPF】Prism学习（十）
  • 第二十七章 TCP 客户端 服务器通信 - 连接管理