1
import (
2
    "net/http"
3
    _ "net/http/pprof"
4
)
5

6
func main() {
7
    // pprof 自动注册到 /debug/pprof/
8
    go func() {
9
        http.ListenAndServe(":6060", nil)
10
    }()
11

12
    // 主服务逻辑...
13
}

1
import (
2
    "runtime/pprof"
3
    "os"
4
)
5

6
func cpuProfile() {
7
    f, _ := os.Create("cpu.pprof")
8
    defer f.Close()
9

10
    // 开始 CPU profiling，持续 30 秒
11
    pprof.StartCPUProfile(f)
12
    defer pprof.StopCPUProfile()
13

14
    // 运行业务代码...
15
}

1
# 交互式分析
2
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
3

4
# 常用命令
5
(pprof) top10        # 查看 CPU 消耗前 10 的函数
6
(pprof) list funcName # 查看具体函数的详细信息
7
(pprof) web          # 生成火焰图（需要 graphviz）

1
# 分析当前堆内存
2
go tool pprof http://localhost:6060/debug/pprof/heap
3

4
# 查看内存分配热点
5
(pprof) top -alloc_space  # 按分配总量排序
6
(pprof) top -inuse_space  # 按使用中内存排序

1
// 原始代码：CPU 热点
2
func processRequest(body []byte) (*Data, error) {
3
    var result map[string]interface{}
4
    if err := json.Unmarshal(body, &result); err != nil {
5
        return nil, err
6
    }
7
    // 处理逻辑...
8
    return &Data{...}, nil
9
}

1
// 优化后：定义明确的结构体
2
type DataRequest struct {
3
    ID     string `json:"id"`
4
    Name   string `json:"name"`
5
    Values []int  `json:"values"`
6
}
7

8
func processRequestOptimized(body []byte) (*DataRequest, error) {
9
    var result DataRequest
10
    if err := json.Unmarshal(body, &result); err != nil {
11
        return nil, err
12
    }
13
    return &result, nil
14
}

1
# 基准测试
2
BenchmarkProcessRequest-8           50000    28500 ns/op    8192 B/op    150 allocs/op
3
BenchmarkProcessRequestOptimized-8 200000     7200 ns/op    1024 B/op     12 allocs/op

1
import (
2
    "runtime/trace"
3
    "os"
4
)
5

6
func main() {
7
    f, _ := os.Create("trace.out")
8
    defer f.Close()
9
    trace.Start(f)
10
    defer trace.Stop()
11

12
    // 业务代码...
13
}

1
go tool trace trace.out

1
go tool pprof -sample_index=inuse_space http://localhost:6060/debug/pprof/heap

1
go tool pprof -sample_index=alloc_space http://localhost:6060/debug/pprof/heap

1
// 问题代码：每次拼接都创建新字符串
2
func concatStrings(parts []string) string {
3
    result := ""
4
    for _, part := range parts {
5
        result += part  // 每次都分配新内存
6
    }
7
    return result
8
}

1
import "strings"
2

3
func concatStringsOptimized(parts []string) string {
4
    var builder strings.Builder
5
    // 预估容量，避免多次扩容
6
    builder.Grow(len(parts) * 16)
7

8
    for _, part := range parts {
9
        builder.WriteString(part)
10
    }
11
    return builder.String()
12
}

1
BenchmarkConcatStrings-8            100000    15000 ns/op   16384 B/op    10 allocs/op
2
BenchmarkConcatStringsOptimized-8  1000000     1500 ns/op    2048 B/op     1 allocs/op

1
// 问题代码：切片未预分配，导致多次扩容
2
func collectResults(items []Item) []Result {
3
    var results []Result  // 容量为 0
4
    for _, item := range items {
5
        results = append(results, process(item))
6
    }
7
    return results
8
}

1
func collectResultsOptimized(items []Item) []Result {
2
    // 预分配已知大小
3
    results := make([]Result, 0, len(items))
4
    for _, item := range items {
5
        results = append(results, process(item))
6
    }
7
    return results
8
}

1
// 模式一：无限增长的缓存
2
var cache = make(map[string]*Item)
3

4
func addToCache(key string, item *Item) {
5
    cache[key] = item  // 只增不减
6
}
7

8
// 模式二：goroutine 泄漏
9
func startWorker() {
10
    go func() {
11
        for {
12
            select {
13
            case <-time.After(time.Hour):  // 无退出条件
14
                doWork()
15
            }
16
        }
17
    }()
18
}
19

20
// 模式三：未关闭的资源
21
func readFile(path string) ([]byte, error) {
22
    f, _ := os.Open(path)
23
    // 忘记 f.Close()
24
    return io.ReadAll(f)
25
}

1
# 比较两个时间点的 heap profile
2
curl -o heap1.pprof http://localhost:6060/debug/pprof/heap
3
# 等待一段时间
4
curl -o heap2.pprof http://localhost:6060/debug/pprof/heap
5

6
# 对比差异
7
go tool pprof -base heap1.pprof heap2.pprof

1
go build -gcflags='-m -m' main.go 2>&1 | grep escape

1
./main.go:10:2: x escapes to heap:
2
./main.go:10:2:   flow: ~r0 = &x:
3
./main.go:10:2:     from &x (address-of) at ./main.go:11:9
4
./main.go:10:2:     from return &x (return) at ./main.go:11:2

1
// 逃逸：接口装箱
2
func printValue(v interface{}) {
3
    fmt.Printf("%v\n", v)
4
}
5

6
func main() {
7
    x := 42
8
    printValue(x)  // x 逃逸：构造 eface{type: *rtype(int), data: &heapInt(42)}
9
}

1
func printValue[T any](v T) {
2
    // 泛型版本，避免接口装箱
3
    fmt.Printf("%v\n", v)
4
}
5

6
func main() {
7
    x := 42
8
    printValue(x)  // x 不逃逸
9
}

1
// 逃逸：闭包捕获外部变量
2
func counter() func() int {
3
    count := 0  // count 逃逸到堆
4
    return func() int {
5
        count++
6
        return count
7
    }
8
}

1
// 原始版本：每次请求都堆分配
2
func handleRequest(w http.ResponseWriter, r *http.Request) {
3
    data := &RequestData{  // 堆分配
4
        Method: r.Method,
5
        Path:   r.URL.Path,
6
    }
7
    process(data)
8
}
9

10
// 优化版本：使用 sync.Pool
11
var dataPool = sync.Pool{
12
    New: func() interface{} {
13
        return &RequestData{}
14
    },
15
}
16

17
func handleRequestOptimized(w http.ResponseWriter, r *http.Request) {
18
    data := dataPool.Get().(*RequestData)
19
    defer dataPool.Put(data)
20

21
    data.Method = r.Method
22
    data.Path = r.URL.Path
23
    process(data)
24
}

1
# 默认值 100：堆增长 100% 时触发 GC
2
GOGC=100 ./myapp
3

4
# 设置为 off：禁用 GC（危险！）
5
GOGC=off ./myapp
6

7
# 更高的值：更少 GC，更高内存占用
8
GOGC=500 ./myapp

1
import "runtime/debug"
2

3
func setGOGC(percent int) {
4
    old := debug.SetGCPercent(percent)
5
    fmt.Printf("GOGC changed from %d to %d\n", old, percent)
6
}

1
import "runtime/debug"
2

3
func setMemoryLimit(bytes int64) {
4
    debug.SetMemoryLimit(bytes)
5
}

1
GODEBUG=gctrace=1 ./myapp

1
gc 1 @0.003s 5%: 0.018+1.2+0.015 ms clock, 0.14+0.52/1.1/0.24+0.12 ms cpu, 4->4->3 MB, 5 MB goal, 8 P

1
// 降低内存占用，增加 GC 频率
2
debug.SetGCPercent(50)
3

4
// 设置内存上限
5
debug.SetMemoryLimit(500 * 1024 * 1024) // 500MB

1
// 降低 GC 频率，增加内存占用
2
debug.SetGCPercent(200)
3

4
// 预留足够的内存余量
5
debug.SetMemoryLimit(2 * 1024 * 1024 * 1024) // 2GB

1
var bufferPool = sync.Pool{
2
    New: func() interface{} {
3
        return new(bytes.Buffer)
4
    },
5
}
6

7
func processData(data []byte) ([]byte, error) {
8
    // 从池中获取
9
    buf := bufferPool.Get().(*bytes.Buffer)
10
    defer func() {
11
        buf.Reset()  // 重置状态
12
        bufferPool.Put(buf)  // 归还池
13
    }()
14

15
    // 使用 buffer
16
    buf.Write(data)
17
    // ... 处理逻辑 ...
18

19
    result := make([]byte, buf.Len())
20
    copy(result, buf.Bytes())
21
    return result, nil
22
}

1
BenchmarkWithoutPool-8    5000000    280 ns/op    128 B/op    2 allocs/op
2
BenchmarkWithPool-8      20000000     60 ns/op      0 B/op    0 allocs/op

1
// 注意事项一：不要存储带有状态的对象
2
type Connection struct {
3
    isConnected bool
4
    // ...
5
}
6

7
var connPool = sync.Pool{
8
    New: func() interface{} {
9
        return &Connection{isConnected: false}
10
    },
11
}
12

13
func getConnection() *Connection {
14
    conn := connPool.Get().(*Connection)
15
    // 必须重置状态！
16
    conn.isConnected = false
17
    return conn
18
}
19

20
// 注意事项二：不要依赖池中对象的存在
21
func riskyCode() {
22
    obj := pool.Get()
23
    // GC 后对象可能不存在
24
    // 不要假设下次 Get 还能拿到同一对象
25
}

1
// 方法一：+ 拼接（小规模 OK）
2
s := "hello" + " " + "world"
3

4
// 方法二：fmt.Sprintf（灵活但慢）
5
s := fmt.Sprintf("%s %s", "hello", "world")
6

7
// 方法三：strings.Builder（大规模推荐）
8
var builder strings.Builder
9
builder.WriteString("hello")
10
builder.WriteString(" ")
11
builder.WriteString("world")
12
s := builder.String()
13

14
// 方法四：strings.Join（已知切片）
15
parts := []string{"hello", "world"}
16
s := strings.Join(parts, " ")

1
BenchmarkConcatPlus-8         10000000    150 ns/op
2
BenchmarkConcatSprintf-8        500000   3200 ns/op
3
BenchmarkConcatBuilder-8       5000000    280 ns/op
4
BenchmarkConcatJoin-8         10000000    120 ns/op

1
// 场景一：已知最终大小
2
func processItems(items []Input) []Output {
3
    // 预分配精确大小
4
    results := make([]Output, len(items))
5
    for i, item := range items {
6
        results[i] = transform(item)
7
    }
8
    return results
9
}
10

11
// 场景二：预估大小
12
func filterItems(items []Input, predicate func(Input) bool) []Output {
13
    // 预估：大约一半元素符合条件
14
    results := make([]Output, 0, len(items)/2)
15
    for _, item := range items {
16
        if predicate(item) {
17
            results = append(results, transform(item))
18
        }
19
    }
20
    return results
21
}

1
# 切片预分配
2
BenchmarkSliceWithoutCap-8     1000000   1500 ns/op   8192 B/op   5 allocs/op
3
BenchmarkSliceWithCap-8        5000000    300 ns/op   4096 B/op   1 allocs/op
4

5
# Map 预分配
6
BenchmarkMapWithoutCap-8        500000   3200 ns/op  16384 B/op   8 allocs/op
7
BenchmarkMapWithCap-8          1000000   1800 ns/op   8192 B/op   1 allocs/op

1
func BenchmarkProcessData(b *testing.B) {
2
    // 准备测试数据（不计入基准时间）
3
    data := generateTestData(1000)
4

5
    // 重置计时器
6
    b.ResetTimer()
7

8
    for i := 0; i < b.N; i++ {
9
        processData(data)
10
    }
11
}
12

13
// 测试不同规模
14
func BenchmarkProcessDataSmall(b *testing.B) {
15
    benchmarkProcessData(b, 100)
16
}
17

18
func BenchmarkProcessDataLarge(b *testing.B) {
19
    benchmarkProcessData(b, 10000)
20
}
21

22
func benchmarkProcessData(b *testing.B, size int) {
23
    data := generateTestData(size)
24
    b.ResetTimer()
25

26
    for i := 0; i < b.N; i++ {
27
        processData(data)
28
    }
29
}

1
# 运行基准测试
2
go test -bench=. -count=10 > old.txt
3

4
# 应用优化...
5

6
# 再次运行
7
go test -bench=. -count=10 > new.txt
8

9
# 对比结果
10
benchstat old.txt new.txt