eleven26

很多时候我们会使用 golang 来作为 web 服务的后端，这时候我们就需要对我们的 http 接口进行测试。Go 语言的标准库提供了一个非常方便的测试工具：net/http/httptest 包，可以用来测试 http 服务。 比如对自己写的 http 接口进行测试，通过 mock 掉 ResponseWriter；又或者在单元测试中 mock 掉对外部的 http 请求，让我们的测试不依赖于外部的 http 服务。

http 测试的作用

1. 测试你写的 http 接口：具体来说，就是测试你的 http handler 是否按照预期工作。比如你的 handler 是否正确的处理了请求参数，是否正确的返回了响应。
2. mock 掉对外部的 http 请求：在单元测试中，我们通常不希望依赖于外部的 http 服务，因为外部的服务可能会有变化，这样会导致我们的测试不稳定。

如何测试你的 http 接口

假设我们有一个返回 Hello, world! 的 http 接口：

1
2
3
4
5
6
7

package main

import "net/http"

func HelloHandler(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello, World!"))
}

我们单元测试中，可能会想知道，自己构建一个 http.Request 得到的响应是否是我们预期的。比如我们想知道，是否返回了 Hello, World!，状态码是否是 200 等。

这个时候，我们就可以使用 httptest.NewRecorder 来模拟一个 http.ResponseWriter，它跟 http.ResponseWriter 的行为一样， 但是它不会真的发送响应到客户端，而是把响应保存在内存中，这样我们就可以方便的测试我们的 handler 是否按照预期工作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

func TestHelloHandler(t *testing.T) {
	// 创建一个请求
	req := httptest.NewRequest("GET", "http://example.com/foo", nil)
	// 创建一个响应
	w := httptest.NewRecorder()
	// 调用我们的处理函数
	HelloHandler(w, req)

	// 检查响应码
	if w.Code != http.StatusOK {
		t.Errorf("响应码错误: %d", w.Code)
	}
	// 检查响应体
	if w.Body.String() != "Hello, World!" {
		t.Errorf("响应体错误: %q", w.Body.String())
	}
}

说明：

• 我们使用 httptest.NewRequest 来创建一个请求，这个请求可以用来模拟一个 http 请求。
• 我们使用 httptest.NewRecorder 来创建一个响应，这个响应可以用来模拟一个 http.ResponseWriter。
• 调用 HelloHandler 的过程实际上等同于我们的 http 服务接收到了一个请求，然后返回了一个响应。
• 最后我们检查了响应码和响应体是否符合预期。

httptest.NewRecorder 返回了一个 ResponseRecorder 实例，它有如下字段：

• Code 记录了响应的状态码
• Body 记录了响应的 body
• HeaderMap 记录了响应的 header
• Flushed 记录了响应是否已经被发送

它具有如下方法：

• Header() 返回响应的 header
• Result() 返回响应的 http.Response 实例
• Write([]byte) 写入响应的 body（它的调用发生在我们的 http handler 中）
• WriteString(string) 写入响应的 body（跟 Write([]byte) 类似，只是参数类型不一样）
• WriteHeader(int) 写入响应的状态码
• Flush() 将响应发送到客户端

总的来说，我们可以通过 httptest.NewRecorder 来模拟一个 http.ResponseWriter，然后调用我们的 handler，最后检查响应是否符合预期。 也就是说，我们不用启动一个真正的 http 客户端来对我们的接口进行测试；当然，我们也不需要真的启动一个真正的 http 服务。

mock 掉对外部的 http 请求

有时候，我们开发的功能会依赖于外部的 http 服务，比如调用一个第三方的接口。在单元测试中，我们通常不希望依赖于外部的服务，因为外部的服务可能会有变化，这样会导致我们的测试不稳定。

如何 mock ？

1. 定义一个 http.Handler 的实现，然后在这个 handler 中返回我们预期的响应
2. 使用 httptest.NewServer 来启动一个 mock http 服务，使用上面的 handler
3. 使用 httptest.Server 实例的 URL 字段来获取这个 mock 服务的地址
4. 最终，当我们访问这个 mock 服务的时候，它会返回我们预期的响应

示例

先定义一个 http.Handler，我们判断请求的路径是 /hello 的时候，返回 Hello, World!：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package main

import "net/http"

type MyHandler struct{}

func (m *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	switch r.URL.Path {
	case "/hello":
		w.Write([]byte("Hello, World!"))
	default:
		http.Error(w, "Not Found", http.StatusNotFound)
	}
}

接着，启动一个 httptest.Server，并指定我们的 HandlerFunc：

1
2
3
4

server := httptest.NewServer(&MyHandler{})
defer server.Close()

println(server.URL)

这里获取到的 server.URL 就是我们的 mock 服务的地址，我们可以通过这个地址来访问我们的 mock 服务。

我们可以将自己代码中访问外部服务的地址替换为 server.URL，这样我们的测试就不会依赖于外部服务，而是依赖于我们自己的 mock 服务。这样就可以实现对外部服务的 mock。

下面是一个完整的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// myFunc 请求 url 并返回响应
func myFunc(url string) string {
	resp, err := http.Get(url)
	if err != nil {
		return err.Error()
	}
	defer resp.Body.Close()

	res, _ := io.ReadAll(resp.Body)
	return string(res)
}

func TestHello(t *testing.T) {
	server := httptest.NewServer(&MyHandler{})
	defer server.Close()

	res := myFunc(server.URL + "/hello")
	if res != "Hello, World!" {
		t.Errorf("Expected 'Hello, World!', got %s", res)
	}
}

上面这个例子中：

1. 我们定义了一个 myFunc 函数，它会请求一个 url 并返回响应
2. 我们定义了一个 TestHello 测试函数，它会启动一个 mock 服务，然后调用 myFunc 函数，最后检查响应是否符合预期

它实现的功能是：我们的 myFunc 函数会请求 mock 服务的 /hello 路径，然后返回响应。 在实际开发中，myFunc 接收的 url 可能是一个外部服务的地址，比如第三方 api 的地址。

有了 httptest，现在我们只需要替换 myFunc 中的 url 为 server.URL，就可以实现对外部服务的 mock。

总结

在本文中，我们深入探讨了如何使用 Go 语言的 net/http/httptest 包来测试 HTTP 服务。我们首先介绍了 HTTP 测试的作用，包括测试自定义的 HTTP 接口以及模拟外部 HTTP 请求，以确保单元测试的稳定性和可控性。

接着，我们详细介绍了如何测试自定义的 HTTP 接口，通过使用 httptest.NewRecorder 来模拟 http.ResponseWriter，从而捕获 HTTP 处理函数的输出。我们还展示了如何检查响应码和响应体，以验证处理函数的行为是否符合预期。

然后，我们讨论了如何模拟外部 HTTP 请求，通过定义一个 http.Handler 并使用 httptest.NewServer 来创建一个 mock HTTP 服务器。我们看到，通过这种方式，我们可以控制外部服务的响应，从而在测试环境中隔离外部依赖。

下载

https://www.anaconda.com/download

使用

1. 查看当前环境列表

1

conda env list

输出：

1
2
3
4

# conda environments:
#
base /opt/anaconda3
gyp  /opt/anaconda3/envs/gyp

2. 创建新环境

1

conda create --name myenv python=3.6

myenv 为环境名称，python=3.6 为指定 Python 版本

3. 激活环境

1

conda activate myenv

4. 退出环境

1

conda deactivate

5. 安装对应依赖库

1

pip install 依赖名

或者：

1

conda install 依赖名

6. 删除环境

1

conda remove --name myenv

仅删除环境里面的一个依赖：

1

conda remove --name myenv 依赖名

7. 查看 conda 版本

1

conda --version

8. 查看当前 conda 环境安装的所有依赖包

1

conda list

其他

1. 导出 conda 环境

1

conda list --explicit > /tmp/export.txt

2. 关闭 terminal 时自动激活环境

1

conda config --set auto_activate_base false

3. 修改镜像源

1
2

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --set show_channel_urls yes

4. 查看当前源命令

1
2

conda config --show channels 
conda config --get channels

5. 修改成默认源

1

conda config --remove-key channels

删除某镜像源：

1

conda config --remove channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/

6. 离线安装 python 依赖

1

conda install /path/to/package.tar.bz2

可以在 https://anaconda.org/ 上下载对应的依赖包。

什么是模糊测试

在 Go 1.18 版本中，Go 引入了一个新的测试工具：模糊测试（Fuzzing）。模糊测试是一种自动化测试技术，它通过随机输入来发现程序中的错误。

模糊测试的原理很简单：随机生成输入，然后运行程序，检查程序的输出是否符合预期。如果程序的输出不符合预期，那么就说明程序中存在错误。

模糊测试的优点是可以发现一些边缘情况下的错误或者可能导致程序崩溃的输入，这些错误很难通过手工测试来发现。因此，模糊测试是一种非常有效的测试方法。

如何进行模糊测试

在这里引入一下官方博客的图：

下面是详细说明：

1. 首先，我们需要创建一个模糊测试函数，函数名以 Fuzz 开头，后面跟着要测试的函数名，函数名第一个字母大写，接收一个 *testing.F 参数。
2. 模糊测试需要写在 _test.go 文件中。
3. 一个模糊测试函数里面，必须包含一个模糊目标，也就是需要调用 (*testing.F).Fuzz 方法，这个方法的第一个参数是 *testing.T，后续是模糊测试自动生成的输入（我们需要使用这些随机的输入去调用我们的函数）。这个模糊目标没有返回值。
4. 一个模糊测试只能有一个模糊目标（也就是上图的 Fuzz target 只能有一个）。
5. 所有的种子语料库的类型必须和 Fuzz 函数的输入参数（上图的 Seed corpus addition 跟 Fuzzing arguments）类型一致，因为模糊测试是根据 Seed corpus 的类型生成的随机参数来传递给 Fuzzing arguments 的。
6. 模糊测试的参数只能是以下的类型：
   • string, []byte
   • int, int8, int16, int32, int64
   • uint, uint8/byte, uint16, uint32, uint64
   • float32, float64
   • bool

模糊测试示例

假设我们有以下这个反转字符串的函数：

1
2
3
4
5
6
7

func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

rune 在 Go 里面是 int32 的别名，用来表示 Unicode 字符（因为 Unicode 字符最多只有 4 字节，所以 rune 足够存储一个 Unicode 字符）。

接着，为这个 Reverse 函数写一个模糊测试函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

func FuzzReverse(f *testing.F) {
    // 种子语料库
	testcases := []string{"Hello, world", " ", "!12345"}
	for _, tc := range testcases {
		f.Add(tc)
	}
    // 模糊目标，orig 是随机生成的输入（根据上面的种子语料库生成）
	f.Fuzz(func(t *testing.T, orig string) {
        // 使用随机生成的输入去调用 Reverse 函数
        // 如果 Reverse 函数返回的结果不等于 orig 的反转，那么就说明 Reverse 函数有问题
		rev := Reverse(orig)
		doubleRev := Reverse(rev)
		if orig != doubleRev {
			t.Errorf("Before: %q, after: %q", orig, doubleRev)
		}
        // 又或者，如果 Reverse 函数返回的结果不是一个有效的 UTF-8 字符串，那么就说明 Reverse 函数有问题
		if utf8.ValidString(orig) && !utf8.ValidString(rev) {
			t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
		}
	})
}

最后，通过下面的命令来执行一下模糊测试：

1

go test -fuzz=FuzzReverse -fuzztime=3s .

输出如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

fuzz: elapsed: 0s, gathering baseline coverage: 0/4 completed
fuzz: elapsed: 0s, gathering baseline coverage: 4/4 completed, now fuzzing with 20 workers
fuzz: minimizing 51-byte failing input file
fuzz: elapsed: 0s, minimizing
--- FAIL: FuzzReverse (0.03s)
    --- FAIL: FuzzReverse (0.00s)
        hello_test.go:25: Before: "\x80", after: "�"
    
    Failing input written to testdata/fuzz/FuzzReverse/98fce631eb9c5dd5
    To re-run:
    go test -run=FuzzReverse/98fce631eb9c5dd5
FAIL
exit status 1
FAIL    main  0.033s

从上述输出可以看到，我们有一个模糊测试的用例失败了，然后 Go 帮我们把错误的测试用例写入到了 testdata/fuzz/FuzzReverse/98fce631eb9c5dd5 文件中：

1
2

go test fuzz v1
string("\x80")

修正这个问题

我们从 98fce631eb9c5dd5 这个文件可以看出，模糊测试给我们生成的字符串并不是一个有效的 UTF-8 字符串，所以我们需要在 FuzzReverse 函数中加入一些判断：

1
2
3
4
5
6
7
8
9
10
11
12

func Reverse(s string) (string, error) {
    // 判断是否是有效的 utf-8 字符串
	if !utf8.ValidString(s) {
		return s, errors.New("input is not valid UTF-8")
	}

	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes), nil
}

在判断到传入的字符串不是有效的 UTF-8 字符串的时候，我们返回一个错误。然后在 FuzzReverse 函数中加入对错误的判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

func FuzzReverse(f *testing.F) {
	testcases := []string{"Hello, world", " ", "!12345"}
	for _, tc := range testcases {
		f.Add(tc)
	}
	f.Fuzz(func(t *testing.T, orig string) {
		rev, err := Reverse(orig)
		if err != nil {
			return
		}
		doubleRev, err := Reverse(rev)
		if err != nil {
			return
		}
		if orig != doubleRev {
			t.Errorf("Before: %q, after: %q", orig, doubleRev)
		}
		if utf8.ValidString(orig) && !utf8.ValidString(rev) {
			t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
		}
	})
}

跳过不是 UTF-8 字符串的测试用例，然后再次执行模糊测试：

1

go test -fuzz=FuzzReverse -fuzztime=3s .

输出如下：

1
2
3
4
5
6

fuzz: elapsed: 0s, gathering baseline coverage: 0/6 completed
fuzz: elapsed: 0s, gathering baseline coverage: 6/6 completed, now fuzzing with 20 workers
fuzz: elapsed: 3s, execs: 1431158 (477041/sec), new interesting: 39 (total: 45)
fuzz: elapsed: 3s, execs: 1431158 (0/sec), new interesting: 39 (total: 45)
PASS
ok      main  3.117s

这次模糊测试通过了，没有发现问题。

运行模糊测试一些建议

模糊测试的时间

需要注意的是，在进行模糊测试的时候，我们可能需要指定一个合适的时间，否则模糊测试可能会一直运行下去。可以通过 -fuzztime 参数来指定模糊测试的时间：

1

go test -fuzz=FuzzReverse -fuzztime=3s .

如果我们需要在 CI 中集成，这个可能是必须的。否则，CI 会一直运行模糊测试。

调整种子语料库

检查提供给模糊器的种子语料库，确保其多样性足以探索各种代码路径，但又不会过于宽泛，导致模糊器陷入过多路径。有时，过于通用的种子会导致模糊器在无益路径上花费过多时间。

并行模糊测试

如果我们需要控制模糊测试的并行度，可以通过 -parallel 参数来指定模糊测试的并行度：

默认情况下，Go 会使用所有的 CPU 核心来运行模糊测试。

1

go test -fuzz=FuzzReverse -fuzztime=3s -parallel=10 .

输出：

1
2
3
4
5
6

fuzz: elapsed: 0s, gathering baseline coverage: 0/52 completed
fuzz: elapsed: 0s, gathering baseline coverage: 52/52 completed, now fuzzing with 10 workers
fuzz: elapsed: 3s, execs: 1164562 (388133/sec), new interesting: 0 (total: 52)
fuzz: elapsed: 3s, execs: 1164562 (0/sec), new interesting: 0 (total: 52)
PASS
ok      main  3.109s

我们从第二行输出可以看到 10 workers，因为我们通过了 -parallel 参数指定了只使用 10 个 CPU 核心来运行模糊测试。

总结

模糊测试是一种自动化测试技术，它通过随机输入来发现程序中的错误。Go 1.18 版本引入了模糊测试，我们可以通过 (*testing.F).Fuzz 方法来进行模糊测试。模糊测试是一种非常有效的测试方法，可以发现一些边缘情况下的错误或者可能导致程序崩溃的输入。

单元测试可以帮助我们发现一些常规路径上的错误，而模糊测试可以帮助我们发现一些边缘情况下的错误。因此，单元测试和模糊测试是互补的，我们可以同时使用这两种测试方法来提高代码的质量。

什么是 Example 测试

Example 测试是 Go 语言中的一种特殊测试，它用于展示函数或方法的使用方式。Example 测试的代码位于 _test.go 文件中，以 Example 开头，后面跟着函数名。

其实，Example 测试是 godoc 工具的一部分，它会读取代码中的 Example 测试，并将其展示在文档中。这样，用户就可以直接在文档中看到函数或方法的使用方式。

可以说，Example 测试是一种文档测试，它不仅可以测试代码，还可以帮助用户更好地理解代码。

一个简单的 Example 测试

1
2
3
4

// hello.go
func Hello() {
	fmt.Println("Hello, World!")
}

1
2
3
4
5

// hello_test.go
func ExampleHello() {
	Hello()
	// Output: Hello, World!
}

我们执行 go test 命令就可以运行 Example 测试：

1

go test -v

如果我们的 Example 测试通过，那么输出结果会是：

1
2
3
4

=== RUN   ExampleHello
--- PASS: ExampleHello (0.00s)
PASS
ok      go-test 0.004s

说明：

1. ExampleHello 是我们的 Example 测试函数名。（注意：Hello 是规范的一部分，实际上是我们的函数名）
2. Example 测试的格式是在代码后面加上 // Output: 注释，后面跟着期望的输出结果。如果实际输出结果和期望的输出结果一致，那么 Example 测试就通过了。
3. Example 测试的目的是展示函数或方法的使用方式，而不只是测试。

Example 跟文档的关系

我们写的所有的 Example 测试都会被 godoc 工具读取，然后展示在文档中。这样，用户就可以直接在文档中看到函数或方法的使用方式。

我们可以通过下面的命令预览文档：

1

godoc -http=:8080

注意，如果找不到 godoc 命令，通过下面的命令安装：

1

go install golang.org/x/tools/cmd/godoc@latest

安装完成后，再将 $GOPATH/bin 目录添加到环境变量中。

示例

假设我的目录结构如下：

1
2
3
4

// go.mod
module mytest

go 1.22

1
2
3
4
5
6
7
8
9

// x/hello.go
package x

import "fmt"

// Hello prints "Hello, World!" to the console.
func Hello() {
	fmt.Println("Hello, World!")
}

1
2
3
4
5
6
7

// x/hello_test.go
package x

func ExampleHello() {
	Hello()
	// Output: Hello, World!
}

在运行了 godoc -http=:8080 命令后，我们可以在浏览器中输入 http://localhost:8080/pkg/mytest/x/ 来查看文档：

我们可以看到 Hello 的文档以及其使用示例。

Example 测试既是测试，又是文档。

Example 测试的命名规范

1. Example 测试的函数名必须以 Example 开头。
2. 遵循以下的命名规范，可以让我们的 Example 在 godoc 中展示在不同的位置。

也就是说，不同的命名规范意味着是写给不同对象的示例。

无序输出的 Example 测试

如果我们的函数或方法的输出是无序的，那么我们可以使用 // Unordered 注释来标记。

1
2
3
4
5
6
7
8
9
10

func ExamplePerm() {
    for _, value := range rand.Perm(5) {
        fmt.Println(value)
    }
    // Unordered output: 4
    // 2
    // 1
    // 3
    // 0
}

一个基本的性能测试

我们以斐波那契数列为例，来看一个基本的性能测试。

需要测试的文件：

1
2
3
4
5
6
7

// fib.go
func fib(n int) int {
	if n == 0 || n == 1 {
		return n
	}
	return fib(n-2) + fib(n-1)
}

测试文件：

1
2
3
4
5
6
7
8

// fib_test.go
import "testing"

func BenchmarkFib(b *testing.B) {
	for i := 0; i < b.N; i++ {
		fib(20)
	}
}

我们可以通过执行下面的命令来运行性能测试：

1

go test -bench .

输出结果：

1
2
3
4
5
6
7

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkFib-20            47515             25053 ns/op
PASS
ok      go-test 1.451s

说明：

• 输出字段说明：
  • goos：操作系统。
  • goarch：CPU 架构。
  • pkg：包名。
  • cpu：CPU 信息。
  • BenchmarkFib-20：测试函数的名字。20 表示 GOMAXPROCS（线程数）的值为 20。
  • 47515：测试函数运行的次数。
  • 25053 ns/op：每次运行的平均耗时，也就是每次操作耗时 25053 纳秒。
• 基准测试函数的名字必须以 Benchmark 开头，后面跟被测试的函数名，函数名的第一个字母必须大写。如上面的 BenchmarkFib。
• 基准测试函数的参数是 *testing.B。
• 运行基准测试的命令是 go test -bench .，其中 . 表示当前目录。
• b.N 是基准测试框架提供的一个参数，表示基准测试函数运行的次数。

如果我们想知道每次操作中内存的分配情况，可以使用 -benchmem 参数：

1

go test -bench . -benchmem

在输出中就会显示每次操作分配的内存情况。

CPU 性能测试及分析

上面的基准测试，我们是直接输出了测试结果，如果我们想要更详细的分析，可以使用 pprof 工具。

我们可以使用下面的测试命令来生成 CPU 性能分析的文件：

1

go test -bench . -cpuprofile=cpu.out

接着，我们可以使用 go tool pprof 来查看分析结果：

1

go tool pprof cpu.out

输出如下：

1
2
3
4
5
6

File: go-test.test
Type: cpu
Time: May 10, 2024 at 3:21pm (CST)
Duration: 1.61s, Total samples = 1.24s (76.86%)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) 

我们可以使用 top 命令来查看 CPU 占用最高的函数：

1
2
3
4
5
6
7
8

(pprof) top
Showing nodes accounting for 1.24s, 100% of 1.24s total
      flat  flat%   sum%        cum   cum%
     1.24s   100%   100%      1.24s   100%  go-test.fib
         0     0%   100%      1.24s   100%  go-test.BenchmarkFib
         0     0%   100%      1.24s   100%  testing.(*B).launch
         0     0%   100%      1.24s   100%  testing.(*B).runN
(pprof) 

我们也可以在 top 命令后面加上一个数字，表示显示前几个占用 CPU 时间最多的函数。比如 top3 表示显示前 3 个。

也就是说，我们可以通过 pprof 工具来查看哪些地方占用了比较多的 CPU 时间，从而进行性能优化。

内存性能测试及分析

上一个例子中，我们并没有在函数中分配内存，我们使用下面这个例子来演示内存性能测试及分析。

需要测试的文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import (
	"math/rand"
	"testing"
	"time"
)

func test(n int) []int {
	rand.Seed(time.Now().UnixNano())
	nums := make([]int, 0, n)
	for i := 0; i < n; i++ {
		nums = append(nums, i)
	}
	return nums
}

func BenchmarkItoa(b *testing.B) {
	for i := 0; i < b.N; i++ {
		test(1000)
	}
}

执行下面的命令来运行内存性能测试：

1

go test -bench . -benchmem -memprofile mem.out

输出如下：

1
2
3
4
5
6
7

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkItoa-20          143871              8169 ns/op            8192 B/op          1 allocs/op
PASS
ok      go-test 1.266s

我们可以看到，在 BenchmarkItoa 这一行中，多了两列，其中 8192 B/op 表示每次操作（每次调用 test 函数）分配了 8192 字节的内存，1 allocs/op 表示每次操作分配了 1 次内存。

这个输出对我们的意义是，尽量减少内存的分配，很多时候可以提高程序的性能。

同样的，我们可以使用 go tool pprof 来查看内存分析结果：

1

go tool pprof mem.out

我们在交互模式下，可以使用 top 命令来查看内存分配最高的函数：

1
2
3
4
5
6
7

(pprof) top
Showing nodes accounting for 1.20GB, 100% of 1.20GB total
      flat  flat%   sum%        cum   cum%
    1.20GB   100%   100%     1.20GB   100%  go-test.test
         0     0%   100%     1.20GB   100%  go-test.BenchmarkItoa
         0     0%   100%     1.20GB   100%  testing.(*B).launch
         0     0%   100%     1.20GB   100%  testing.(*B).runN

通过 http 页面的方式展示性能测试结果

我们上面这两个例子还是过于简单了，在实际的项目中，函数调用可能会非常复杂，我们可以通过 web 界面来展示性能测试结果。同时，交互上也会更加友好。

比如，针对上面的 mem.out，我们可以使用下面的命令来启动一个 http 服务：

1

go tool pprof -http=:8081 mem.out

接着，我们可以在浏览器中输入 http://localhost:8081 来查看性能测试结果：

除了直接看到的结果，还可以操作上面的菜单来实现不同的展示方式，比如选择 VIEW->Top，展示出来的是一个列表：

pprof 的其他功能

在我们使用 go tool pprof 的时候，还有很多其他的功能，比如：

• top：查看 CPU 或内存占用最高的函数。上面有介绍。
• list：list 命令后跟函数名称以显示该函数的源代码，突出显示哪些代码占用了最多的 CPU 或内存，如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13

(pprof) list go-test.test
Total: 1.20GB
ROUTINE ======================== go-test.test in /Users/ruby/GolandProjects/go-test/fib_test.go
    1.20GB     1.20GB (flat, cum)   100% of Total
         .          .      9:func test(n int) []int {
         .          .     10:   rand.Seed(time.Now().UnixNano())
    1.20GB     1.20GB     11:   nums := make([]int, 0, n)
         .          .     12:   for i := 0; i < n; i++ {
         .          .     13:           nums = append(nums, i)
         .          .     14:   }
         .          .     15:   return nums
         .          .     16:}
(pprof) 

• web：web 命令可以在浏览器中打开一个页面，以图形的形式展示性能测试结果，如下

• weblist：weblist 命令可以在浏览器中打开一个页面，显示函数的源代码，突出显示哪些代码占用了最多的 CPU 或内存，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// ... 其他内容
/Users/ruby/GolandProjects/go-test/fib_test.go

  Total:      1.20GB     1.20GB (flat, cum)   100%
      6            .          .           	"time" 
      7            .          .           ) 
      8            .          .            
      9            .          .           func test(n int) []int { 
     10            .          .           	rand.Seed(time.Now().UnixNano()) 
     11       1.20GB     1.20GB           	nums := make([]int, 0, n) 
     12            .          .           	for i := 0; i < n; i++ { 
     13            .          .           		nums = append(nums, i) 
     14            .          .           	} 
     15            .          .           	return nums 
// ... 其他内容

• peek：显示某一个函数的调用详情，如：

1
2
3
4
5
6
7
8
9
10

(pprof) peek go-test.test
Active filters:
   show=go-test.test
Showing nodes accounting for 1.20GB, 100% of 1.20GB total
----------------------------------------------------------+-------------
      flat  flat%   sum%        cum   cum%   calls calls% + context              
----------------------------------------------------------+-------------
                                            1.20GB   100% |   go-test.BenchmarkItoa
    1.20GB   100%   100%     1.20GB   100%                | go-test.test
----------------------------------------------------------+-------------

• text：以文本的形式展示性能分析结果，如：

1
2
3
4
5
6
7
8
9

(pprof) text
Active filters:
   show=go-test.test
Showing nodes accounting for 1.20GB, 100% of 1.20GB total
      flat  flat%   sum%        cum   cum%
    1.20GB   100%   100%     1.20GB   100%  go-test.test
         0     0%   100%     1.20GB   100%  go-test.BenchmarkItoa
         0     0%   100%     1.20GB   100%  testing.(*B).launch
         0     0%   100%     1.20GB   100%  testing.(*B).runN

• 各种形式的输出：pprof 还支持其他的输出形式，比如 pdf、png、svg 等，具体可以查看 help 命令。

testing.B 的其他方法

最后，再简单介绍一下 testing.B 的其他方法：

• b.ResetTimer()：重置计时器，可以在测试函数中的循环体中使用，以避免循环体的初始化时间影响测试结果。

1
2
3
4
5
6
7
8

func BenchmarkFib(b *testing.B) {
  // 模拟初始化时间，这一行代码不会计入测试时间
  time.Sleep(1 * time.Second)
  b.ResetTimer()
  for i := 0; i < b.N; i++ {
    fib(20)
  }
}

• b.StartTimer()：负责启动计时并初始化内存相关计数，测试执行时会自动调用，一般不需要用户启动。
• b.StopTimer()：负责停止计时，并累加相应的统计值。
• b.ReportAllocs()：用于设置是否打印内存统计信息，与命令行参数 -benchmem 一致，但本方法只作用于单个测试函数。
• b.SetParallelism(p int)：设置并行测试的线程数，设置为 p*GOMAXPROCS。影响 b.RunParallel 的并行度。
• b.RunParallel(body func(*PB))：用于并行测试，body 函数会被并行执行，b.N 会被分配到各个并行体中。通常跟 -cpu 参数一起使用。

其他方法跟 testing.T 有很多重复的，这里不赘述了，可以看上一篇。

高阶用法

指定性能测试时间

可以通过 -benchtime 参数来指定性能测试的时间，如：

1

go test -bench . -benchtime=3s

输出：

1
2
3
4
5
6
7

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkItoa-20          499718              7051 ns/op
PASS
ok      go-test 3.602s

指定性能测试执行次数，也就是 b.N

也是通过 -benchtime 参数来指定，但是单位是 x，如：

1

go test -bench . -benchtime=3x

输出：

1
2
3
4
5
6
7

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkItoa-20               3             14378 ns/op
PASS
ok      go-test 0.005s

执行多次性能测试

可以通过 -count 参数来指定执行多少次性能测试，如：

1

go test -bench . -count=3

输出：

1
2
3
4
5
6
7
8
9

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkItoa-20          166116              7187 ns/op
BenchmarkItoa-20          165289              7168 ns/op
BenchmarkItoa-20          161872              7146 ns/op
PASS
ok      go-test 3.765s

指定性能测试的 CPU 数

可以通过 -cpu 参数来指定性能测试的 CPU 数，如：

1

go test -bench . -cpu=1,2,4

这个命令会执行多次性能测试，分别使用 1、2、4 个 CPU（也就是 GOMAXPROCS 的值分别为 1、2、4）。

输出：

1
2
3
4
5
6
7
8
9

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkItoa             166363              7153 ns/op
BenchmarkItoa-2           170436              7114 ns/op
BenchmarkItoa-4           171088              6976 ns/op
PASS
ok      go-test 3.819s

输出内存分配信息

可以通过 -benchmem 参数来输出内存分配信息，如：

1

go test -bench . -benchmem

输出：

1
2
3
4
5
6
7

goos: darwin
goarch: amd64
pkg: go-test
cpu: 12th Gen Intel(R) Core(TM) i7-12700F
BenchmarkItoa-20          163878              7081 ns/op             896 B/op          1 allocs/op
PASS
ok      go-test 1.240s