一、Go基础知识40、调试：DLV工具

一、Go语言基础

1、Go语言的基本语法和特性

我的Go语言专栏-索引目录

2、理解Go程序的构建和执行过程

2.1 Hello, World!

示例：

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

• package main: Go程序的执行从main包开始。
• import "fmt": 引入fmt包，用于格式化输入和输出。
• func main(): 所有的Go程序都从main函数开始执行。
• fmt.Println("Hello, World!"): 打印输出"Hello, World!"。

2.2 构建和执行

保存上述代码到一个文件，如 hello.go。然后，打开终端，切换到包含这个文件的目录，并执行以下命令：

go run hello.go

这将编译并运行程序，输出是 “Hello, World!”。

2.3 Go程序的构建过程

当使用 go run 命令时，Go会自动进行以下步骤：

• 编译源代码： Go源代码会被编译成机器码。
• 生成可执行文件： 编译过程将生成一个可执行文件，通常在同一目录下。
• 运行程序： 最后，Go会执行生成的可执行文件。

2.4 Go程序的执行过程

1. main() 函数： 执行从 main 函数开始。
2. 引入包： 使用 import 语句引入需要的包。
3. 执行代码： 执行 main 函数中的代码。

二、安装DLV

DLV的调试器命令与GDB（GNU调试器）类似。

1、下载并安装DLV工具

1.1 安装DLV工具

1. 打开终端： 打开终端或命令提示符。

2. 使用go get命令安装DLV：

   go get -u github.com/go-delve/delve/cmd/dlv
   

   这将从GitHub上下载DLV源代码并将其安装到Go工作空间。

3. 等待安装完成：
   等待go get命令完成下载和安装过程。一旦安装完成，DLV就会被放置在Go工作空间的bin目录中。

1.2 验证DLV安装

1. 执行以下命令验证安装：

   dlv version
   

   如果一切顺利，应该看到DLV的版本信息，表明它已经成功安装。

1.3 使用DLV调试程序

1. 在项目中启动DLV调试：

   • 进入Go项目目录。
   • 执行以下命令启动调试器：

     dlv debug
     

     或者，如果有一个可执行文件：

     dlv exec ./your_executable
     

     请将./your_executable替换为Go可执行文件的路径。

2. DLV调试器交互界面：
   DLV将启动一个交互式命令行界面，可以在这里输入不同的命令以控制调试过程。例如，可以使用 break 命令在代码中设置断点。

3. 运行调试：
   使用 continue 命令启动程序执行，或使用其他命令进行单步执行、查看变量值等操作。

2、熟悉DLV的基本命令和用法

DLV命令详解

2.1 启动调试

• 启动调试：

  dlv debug
  

  或者，如果有一个可执行文件：

  dlv exec ./your_executable
  

  请将./your_executable替换为Go可执行文件的路径。

2.2 基本调试命令

• 运行程序：

  continue
  

  执行程序直到下一个断点或程序结束。

• 单步执行：

  step
  

  单步执行到下一行代码。

• 下一步：

  next
  

  执行当前函数的下一行代码。

• 查看变量值：

  print variableName
  

  替换 variableName 为想要查看的变量名称，用于查看特定变量的值。

2.3 断点和观察

• 设置断点：

  break package/path/to/file.go:lineNumber
  

  在指定文件和行号设置断点。

• 列出所有断点：

  breakpoints
  

  列出所有已设置的断点。

• 清除断点：

  clear package/path/to/file.go:lineNumber
  

  清除指定文件和行号上的断点。

2.4 栈和调用信息

• 查看当前堆栈：

  stack
  

  查看当前调用堆栈的信息。

• 查看调用信息：

  list
  

  显示当前位置附近的源代码。

2.5 退出调试

• 退出调试器：

  exit
  

  退出DLV调试器。

三、基本调试技巧

从这里开始，将会以完整流程形式进行说明。

1、设置断点以暂停程序执行 & 查看变量和表达式的值

当使用DLV进行Go程序调试时，设置断点可以在程序执行到特定位置时暂停。

1.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件，使用以下命令：

dlv exec ./your_executable

1.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。

以下是设置断点的基本语法：

break package/path/to/file.go:lineNumber

替换 package/path/to/file.go 为想要设置断点的文件路径，将 lineNumber 替换为文件中的行号。

例如，要在文件 main.go 的第 10 行设置断点：

break main.go:10

1.3 查看断点

可以使用 breakpoints 命令查看所有已设置的断点：

breakpoints

这将列出所有断点及其相关信息。

1.4 启动程序执行

一旦设置了断点，可以使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

1.5 暂停程序执行

当程序执行到设置的断点时，DLV会自动暂停。在终端或命令提示符中可以看到类似于下面的消息：

(dlv) 	Stopped at: main.go:10

这表示程序已在设置的断点处停止执行。

1.6 查看变量和调用栈

在程序暂停时，可以使用其他命令来查看变量的值和调用栈的信息。

例如，可以使用 print 命令查看变量：

print variableName

也可以一次查看多个变量的值：

print var1, var2, var3

可以使用 stack 命令查看调用栈：

stack

1.7 继续执行

一旦查看了变量或调用栈信息，您可以使用 continue 命令继续执行程序：

continue

这将使程序继续执行直到下一个断点或程序结束。

1.8 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

2、单步执行代码并观察程序状态

当使用DLV进行Go程序调试时，单步执行代码可以帮助逐行观察程序的执行状态。

2.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件，使用以下命令：

dlv exec ./your_executable

2.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。

以下是设置断点的基本语法：

break package/path/to/file.go:lineNumber

替换 package/path/to/file.go 为想要设置断点的文件路径，将 lineNumber 替换为文件中的行号。

例如，要在文件 main.go 的第 10 行设置断点：

break main.go:10

2.3 启动程序执行

一旦设置了断点，可以使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

2.4 单步执行代码

当程序执行到设置的断点时，可以使用 step 命令进行单步执行。这将使程序执行一行代码并停在下一行。

step

2.5 查看程序状态

在每次单步执行后，可以使用 print 命令来查看变量和表达式的值，以观察程序状态。

例如，可以使用 print 命令查看变量：

print variableName

也可以一次查看多个变量的值：

print var1, var2, var3

2.6 继续单步执行

使用 step 命令可以继续执行下一行代码。可以一直使用 step 命令，逐步观察程序的执行状态。

2.7 跳过函数调用

如果不希望进入函数内部，可以使用 next 命令，它将执行当前函数并停在下一个断点或程序结束：

next

2.8 继续执行

一旦完成了对程序的观察，可以使用 continue 命令继续执行程序，直到下一个断点或程序结束：

continue

2.9 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

四、条件断点和观察点

当使用DLV进行Go程序调试时，条件断点和观察点可以在特定条件下暂停程序执行。

1、在特定条件下暂停程序

1.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

1.2 设置条件断点

在DLV调试器中，可以使用 break 命令来设置条件断点。条件断点将在满足特定条件时暂停程序执行。

设置条件断点的基本语法：

break package/path/to/file.go:lineNumber if condition

替换 package/path/to/file.go 为想要设置断点的文件路径，将 lineNumber 替换为文件中的行号，将 condition 替换为满足时暂停的条件表达式。

例如，要在文件 main.go 的第 10 行设置一个条件断点，当变量 i 的值为 5 时暂停：

break main.go:10 if i == 5

1.3 设置观察点

观察点允许在特定条件下观察变量或表达式的值，而不会暂停程序执行。可以使用 trace 命令来设置观察点。

设置观察点的基本语法：

trace package/path/to/file.go:lineNumber if condition

替换 package/path/to/file.go 为想要设置观察点的文件路径，将 lineNumber 替换为文件中的行号，将 condition 替换为满足时观察的条件表达式。

例如，要在文件 main.go 的第 15 行设置一个观察点，当变量 j 的值大于 10 时观察：

trace main.go:15 if j > 10

1.4 查看观察点

一旦设置了观察点，当满足条件时，DLV将显示观察的变量或表达式的值，而不会暂停程序执行。

1.5 启动程序执行

一旦设置了条件断点和观察点，可以使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

1.6 暂停程序执行

当程序执行到满足条件的断点时，或观察点的条件满足时，DLV将暂停程序执行。

1.7 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

2、添加观察点以监视变量和表达式

观察点可以帮助监视变量和表达式的值，而不会暂停程序的执行。

2.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

2.2 设置观察点

使用 trace 命令来设置观察点。观察点允许在程序执行时观察变量或表达式的值，而不会暂停程序。

设置观察点的基本语法：

trace package/path/to/file.go:lineNumber if condition

替换 package/path/to/file.go 为想要设置观察点的文件路径，将 lineNumber 替换为文件中的行号，将 condition 替换为观察的条件表达式。

例如，要在文件 main.go 的第 15 行设置一个观察点，监视变量 j 的值：

trace main.go:15

2.3 启动程序执行

一旦设置了观察点，可以使用 continue 命令启动程序执行，直到达到观察点或程序结束：

continue

2.4 查看观察点

当程序执行到设置的观察点时，DLV将显示监视的变量或表达式的值，而不会暂停程序执行。

2.5 继续执行

如果需要，可以使用 continue 命令继续执行程序：

continue

2.6 清除观察点

要清除观察点，可以使用 untrace 命令，指定观察点的位置：

untrace package/path/to/file.go:lineNumber

2.7 查看观察点列表

可以使用 trace 命令查看当前设置的观察点列表：

trace

2.8 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

五、控制程序执行流程

1、跳转到特定的代码位置

1.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

1.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。断点允许暂停程序的执行，从而能够在那里进行流程控制。

使用以下命令设置断点：

break package/path/to/file.go:lineNumber

替换 package/path/to/file.go 为想要设置断点的文件路径，将 lineNumber 替换为文件中的行号。

1.3 启动程序执行

一旦设置了断点，可以使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

1.4 控制程序流程

一旦程序执行到断点，可以使用 step 命令单步执行，或使用 next 命令执行到下一个断点。

如果想直接跳转到特定的代码位置，可以使用 restart 命令。例如，要跳转到文件 main.go 的第 20 行：

restart main.go:20

1.5 继续执行

一旦跳转到特定的代码位置或完成对代码的观察，可以使用 continue 命令继续执行程序，直到下一个断点或程序结束：

continue

1.6 清除断点

要清除设置的断点，可以使用 clear 命令，指定断点的位置：

clear package/path/to/file.go:lineNumber

1.7 查看断点列表

可以使用 breakpoints 命令查看当前设置的断点列表：

breakpoints

1.8 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

2、跳过函数调用或进入函数

2.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

2.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。断点允许暂停程序的执行，从而能够在那里进行流程控制。使用以下命令设置断点：

break package/path/to/file.go:lineNumber

替换 package/path/to/file.go 为想要设置断点的文件路径，将 lineNumber 替换为文件中的行号。

2.3 启动程序执行

一旦设置了断点，可以使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

2.4 跳过函数调用

如果希望跳过当前函数的执行并直接进入下一个断点，可以使用 next 命令：

next

这将使程序执行到当前函数的末尾，然后停在下一个断点或程序结束。

2.5 进入函数调用

如果希望进入当前函数内部进行逐步调试，可以使用 step 命令：

step

这将导致程序进入当前函数的内部，逐步执行其中的语句，直到遇到下一个断点或函数返回。

2.6 继续执行

一旦跳过或进入函数进行调试，可以使用 continue 命令继续执行程序，直到下一个断点或程序结束：

continue

2.7 清除断点

要清除设置的断点，可以使用 clear 命令，指定断点的位置：

clear package/path/to/file.go:lineNumber

2.8 查看断点列表

可以使用 breakpoints 命令查看当前设置的断点列表：

breakpoints

2.9 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

六、处理异常和错误

1、捕获和处理运行时异常

1.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

1.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。断点将允许暂停程序执行，以便检查异常。

使用以下命令设置断点：

break package/path/to/file.go:lineNumber

1.3 启动程序执行

使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

1.4 检查异常

一旦程序执行到断点，可以使用 locals 命令查看当前作用域的局部变量和其值，以检查异常的相关信息：

locals

1.5 捕获异常

在Go中，异常通常是通过返回值来处理的，而不是像其他语言一样使用异常对象。

因此，需要检查函数的返回值是否包含错误信息。使用 print 命令查看函数返回值：

print yourFunction()

替换 yourFunction() 为要检查的函数调用。

1.6 处理错误

如果发现错误，可以使用条件语句如 if 或 switch 来处理错误。

例如：

if err != nil {
    // 处理错误的逻辑
    fmt.Println("发生错误:", err)
    // 可以使用 `continue` 继续执行程序
    continue
}

1.7 继续执行

一旦处理了错误或异常，可以使用 continue 命令继续执行程序，直到下一个断点或程序结束：

continue

1.8 清除断点

要清除设置的断点，可以使用 clear 命令，指定断点的位置：

clear package/path/to/file.go:lineNumber

1.9 查看断点列表

可以使用 breakpoints 命令查看当前设置的断点列表：

breakpoints

1.10 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

2、使用DLV识别和解决常见问题

2.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

2.2 检查错误消息

如果程序在启动时遇到错误，DLV通常会显示相关的错误消息。

仔细阅读错误消息，尝试理解找到解决方法。

2.3 设置断点

使用 break 命令设置断点，以便在程序执行到特定位置时暂停：

break package/path/to/file.go:lineNumber

2.4 启动程序执行

使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

2.5 检查局部变量

一旦程序暂停，使用 locals 命令查看当前作用域的局部变量和其值：

locals

2.6 查看堆栈信息

使用 stack 命令查看当前堆栈信息，以确定程序的执行路径：

stack

2.7 解决错误

根据错误消息、局部变量和堆栈信息，尝试定位并解决问题。可能需要修改代码或调整程序逻辑。

2.8 处理异常

如果程序在运行时遇到异常，可以使用 catch 命令来捕获异常：

catch

然后，使用 continue 继续执行程序。

2.9 清除断点

要清除设置的断点，可以使用 clear 命令，指定断点的位置：

clear package/path/to/file.go:lineNumber

2.10 查看断点列表

可以使用 breakpoints 命令查看当前设置的断点列表：

breakpoints

2.11 退出调试

如果程序执行完毕或想要退出调试器，可以使用 exit 命令：

exit

七、多线程调试

1、调试并发和并行代码

1.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

1.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。可以在主线程或特定线程上设置断点。

例如，在主线程上设置断点：

break package/path/to/file.go:lineNumber

或者，在特定线程上设置断点：

break --thread=THREAD_ID package/path/to/file.go:lineNumber

1.3 启动程序执行

使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

1.4 查看并发和并行信息

使用 threads 命令查看当前程序中所有线程的信息：

threads

使用 thread THREAD_ID 命令切换到特定线程：

thread THREAD_ID

1.5 设置条件断点

可以使用 break 命令设置条件断点，以仅在满足某些条件时暂停程序。

例如，在某个变量等于特定值时暂停：

break package/path/to/file.go:lineNumber if variable == value

1.6 检查每个线程的状态

使用 info threads 命令查看每个线程的当前状态：

info threads

1.7 检查并发和并行代码中的变量

使用 locals 命令查看当前作用域的局部变量和其值：

locals

1.8 检查堆栈信息

使用 stack 命令查看当前堆栈信息，以确定每个线程的执行路径：

stack

1.9 处理并发和并行异常

如果在并发和并行代码中发生异常，可以使用 catch 命令捕获异常：

catch

然后，使用 continue 继续执行程序。

1.10 清除断点

要清除设置的断点，可以使用 clear 命令，指定断点的位置：

clear package/path/to/file.go:lineNumber

1.11 查看断点列表：

可以使用 breakpoints 命令查看当前设置的断点列表：

breakpoints

2、查看和管理goroutines的状态

当使用DLV进行Go程序的多线程调试时，查看和管理goroutines的状态是非常重要的。以下是详细的步骤和说明，以帮助您在DLV中查看和管理goroutines：

2.1 启动调试

首先，进入Go项目目录，并使用以下命令启动DLV调试器：

dlv debug

或者，如果有一个可执行文件：

dlv exec ./your_executable

2.2 设置断点

在DLV调试器中，可以使用 break 命令来设置断点。可以在主线程或特定线程上设置断点。

例如，在主线程上设置断点：

break package/path/to/file.go:lineNumber

或者，在特定线程上设置断点：

break --thread=THREAD_ID package/path/to/file.go:lineNumber

2.3 启动程序执行

使用 continue 命令启动程序执行，直到达到断点或程序结束：

continue

2.4 查看goroutines信息

使用 goroutines 命令查看当前程序中所有goroutines的信息：

goroutines

2.5 切换到特定goroutine

如果想查看特定goroutine的信息，可以使用 goroutine GoroutineID 命令：

goroutine GoroutineID

2.6 检查goroutine的局部变量

在特定goroutine上使用 locals 命令查看当前作用域的局部变量和其值：

locals

2.7 检查goroutine的堆栈信息

在特定goroutine上使用 stack 命令查看当前堆栈信息：

stack

2.8 暂停和恢复goroutine

使用 halt GoroutineID 命令暂停特定goroutine的执行：

halt GoroutineID

使用 continue GoroutineID 命令恢复特定goroutine的执行：

continue GoroutineID

2.9 杀死goroutine

如果需要终止特定goroutine，可以使用 kill GoroutineID 命令：

kill GoroutineID

2.10 清除断点

要清除设置的断点，可以使用 clear 命令，指定断点的位置：

clear package/path/to/file.go:lineNumber

2.11 查看断点列表

可以使用 breakpoints 命令查看当前设置的断点列表：

breakpoints

八、高级调试技巧

1、了解和使用DLV的高级功能

1.1 条件断点

使用 break 命令设置条件断点，以仅在满足某些条件时暂停程序。

例如，在某个变量等于特定值时暂停：

break package/path/to/file.go:lineNumber if variable == value

1.2 Watchpoints

设置 watch 命令以监视特定变量，并在该变量的值发生更改时暂停程序：

watch variable

1.3 Tracepoints

使用 trace 命令设置tracepoint，在程序执行到特定代码位置时输出一些信息：

trace package/path/to/file.go:lineNumber

1.4 查看汇编代码

使用 disassemble 命令查看当前执行位置的汇编代码：

disassemble

1.5 性能分析

DLV提供了性能分析功能，使用 trace 命令跟踪程序的执行时间：

trace --profile

1.6 反汇编

通过 disassemble 命令查看函数的反汇编代码：

disassemble functionName

1.7 查看和修改寄存器状态

使用 regs 命令查看当前寄存器状态：

regs

通过 set 命令修改寄存器的值：

set $registerName = value

1.8 远程调试

DLV支持远程调试，可以在远程机器上运行调试器，通过网络连接到它：

dlv connect remote target:port

1.9 使用Core文件

DLV支持使用core文件进行调试，可以使用以下命令启动：

dlv core coreDumpFile

1.10 动态调试

在运行时修改变量的值，使用 call 命令调用函数，以便在调试期间动态修改程序状态：

call variable = value
call functionName(args)

1.11 调试测试

使用DLV调试Go测试，可以通过以下命令运行：

dlv test

1.12 调试子进程

如果程序启动了子进程，可以使用 continue 和 halt 命令在父进程和子进程之间切换调试：

continue --pid=PID
halt --pid=PID

2、对性能进行调优和分析

2.1 性能分析

DLV提供了性能分析功能，使用 trace 命令可以跟踪程序的执行时间，帮助找到性能瓶颈：

trace --profile

2.2 查看性能分析结果

分析完成后，可以使用 pprof 工具查看生成的性能分析文件。

运行以下命令：

go tool pprof <binary> trace.out

然后在pprof命令行中输入web以在浏览器中查看可视化性能分析结果。

2.3 实时性能追踪

使用 trace 命令进行实时性能追踪，可以在程序运行时捕获性能信息：

trace --pprof :<port>

然后，可以使用 go tool pprof 连接到指定端口查看实时性能信息。

2.4 内存分析

DLV还支持内存分析，您可以使用 trace 命令捕获内存分配和释放的信息：

trace --memprofile mem.out

查看内存分析结果：

go tool pprof <binary> mem.out

2.5 查看Goroutine和堆栈信息

使用 goroutines 命令查看当前程序中所有goroutines的信息：

goroutines

使用 stack 命令查看当前堆栈信息：

stack

2.6 CPU Profiling

使用 trace 命令进行CPU profiling，以收集CPU利用率信息：

trace --cpuprofile cpu.out

查看CPU profiling结果：

go tool pprof <binary> cpu.out

2.7 检查资源使用情况

使用 info proc 命令查看当前程序的资源使用情况，包括CPU、内存和文件句柄：

info proc

2.8 查看并调整并发度：

使用 info threads 命令查看当前程序中所有线程的信息，了解并发度：

info threads

可以根据线程信息来调整并发度，优化程序性能。

3、go tool trace性能分析

3.1 生成Trace文件

首先，需要在运行您的Go程序时生成Trace文件。

运行以下命令：

go run -trace=trace.out your_program.go

3.2 可视化Trace文件

使用go tool trace命令来可视化Trace文件：

go tool trace trace.out

此命令将启动一个本地Web服务器，并在浏览器中打开Trace视图。

可以通过访问http://localhost:8080来查看性能分析的详细信息。

3.3 分析Goroutines和事件

在Trace视图中，可以查看程序执行期间的所有Goroutines以及各种事件的时间轴。

可以帮助了解程序的并发情况和事件的发生顺序。

3.4 查看函数执行时间

Trace视图还提供了函数执行时间的图表，可以帮助识别哪些函数占用了大部分时间。

点击函数名称可以查看更详细的信息。

3.5 内存分析

Trace文件中还包含有关内存分配和释放的信息。

可以查看内存图表，以了解程序的内存使用情况。

3.6 查看系统资源利用率

Trace视图中的"Syscall"图表显示了系统调用的执行时间。

3.7 网络事件分析

如果程序涉及网络操作，Trace视图中的"Net"图表将显示与网络相关的事件，帮助识别潜在的性能瓶颈。

3.8 用户自定义事件

还可以在代码中使用trace.Start和trace.Stop来记录自定义事件，并在Trace视图中查看这些事件的发生时间。

import "runtime/trace"

// 在需要追踪的代码段开始处调用
trace.Start(os.Stderr)
defer trace.Stop()

3.9 调整分析时间范围

Trace视图中有一个时间轴，可以选择特定时间范围进行分析，以便更详细了解程序在不同阶段的性能表现。

4、go tool pprof性能分析

4.1 生成CPU Profiling文件

首先，需要在运行您的Go程序时生成CPU Profiling文件。

运行以下命令：

go run -cpuprofile=cpu.pprof your_program.go

4.2 使用go tool pprof查看性能分析

使用go tool pprof命令来查看CPU Profiling文件：

go tool pprof cpu.pprof

这将进入交互式界面，可以在命令行中输入各种命令来查看不同方面的性能分析信息。

4.3 查看Top函数

在pprof交互界面中，输入top命令将显示占用CPU时间最多的函数列表。

可以帮助确定哪些函数是性能瓶颈。

top

4.4 查看函数调用图

使用web命令可以在浏览器中查看函数调用图，更直观地了解函数之间的调用关系。

web

4.5 查看函数的CPU Profiling图表

使用list命令查看特定函数的CPU Profiling图表，了解函数内部的性能情况。

list functionName

4.6 Memory Profiling

如果还想进行内存分析，可以生成内存分析文件：

go run -memprofile=mem.pprof your_program.go

然后使用go tool pprof查看内存分析：

go tool pprof mem.pprof

4.7 查看Goroutine情况

使用goroutine命令查看程序中所有goroutines的信息，了解并发情况。

goroutine

4.8 查看Heap分配情况

使用heap命令查看Heap分配情况，了解内存的分配和使用情况。

heap

4.9 查看线程情况

使用threadcreate命令查看线程创建的情况，对于并发性能问题很有帮助。

threadcreate

4.10 生成可视化图表

go tool pprof还支持生成SVG、PDF等格式的图表，以便更好地可视化性能分析结果。

go tool pprof -png cpu.pprof > cpu.png