Go 性能优化

性能优化是编写高质量 Go 程序的重要环节。Go 语言以其出色的性能著称，但不当的使用方式仍然可能导致性能问题。本章将系统介绍 Go 性能优化的方法和工具，帮助你编写更高效的程序。

性能优化原则

先测量，后优化

在优化之前，必须先测量找出瓶颈。盲目优化不仅浪费时间，还可能引入新问题：

// 错误的做法：凭感觉优化
// "我觉得这里可能慢，改一下"

// 正确的做法：先用基准测试找出瓶颈
func BenchmarkMyFunction(b *testing.B) {
    for i := 0; i < b.N; i++ {
        MyFunction()
    }
}

运行基准测试：

go test -bench=. -benchmem

性能优化的优先级

1. 算法优化：选择正确的算法和数据结构（影响最大）
2. 避免不必要的操作：减少内存分配、避免重复计算
3. 并发优化：充分利用多核 CPU
4. 微优化：在热点路径上进行细节优化（影响最小）

基准测试

基准测试是性能优化的基础。Go 内置了强大的基准测试支持。

基本基准测试

package main

import "testing"

func Fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return Fibonacci(n-1) + Fibonacci(n-2)
}

// 基准测试函数必须以 Benchmark 开头
func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

// Go 1.24+ 推荐使用 b.Loop()
func BenchmarkFibonacciLoop(b *testing.B) {
    for b.Loop() {
        Fibonacci(20)
    }
}

运行基准测试：

# 运行所有基准测试
go test -bench=.

# 运行特定基准测试
go test -bench=Fibonacci

# 显示内存分配统计
go test -bench=. -benchmem

# 运行更长时间获得更稳定的结果
go test -bench=. -benchtime=5s

# 运行多次取平均值
go test -bench=. -count=5

子基准测试

func BenchmarkSort(b *testing.B) {
    data := make([]int, 1000)
    for i := range data {
        data[i] = i
    }
    
    b.Run("Small", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            small := make([]int, 10)
            copy(small, data[:10])
            sort.Ints(small)
        }
    })
    
    b.Run("Medium", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            medium := make([]int, 100)
            copy(medium, data[:100])
            sort.Ints(medium)
        }
    })
    
    b.Run("Large", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            large := make([]int, 1000)
            copy(large, data)
            sort.Ints(large)
        }
    })
}

基准测试输出解读

$ go test -bench=. -benchmem
BenchmarkFibonacci-8     3000000               405 ns/op             0 B/op          0 allocs/op

输出说明：

字段	说明
BenchmarkFibonacci-8	测试名称和 GOMAXPROCS
3000000	执行次数
405 ns/op	每次操作耗时
0 B/op	每次操作分配内存
0 allocs/op	每次操作分配次数

重置计时器

当基准测试包含准备工作时，需要重置计时器：

func BenchmarkWithSetup(b *testing.B) {
    // 准备工作（不计入基准时间）
    data := make([]int, 1000000)
    for i := range data {
        data[i] = i
    }
    
    // 重置计时器
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        process(data)
    }
}

// 或者停止/开始计时
func BenchmarkComplex(b *testing.B) {
    for i := 0; i < b.N; i++ {
        b.StopTimer()
        data := prepareData()
        b.StartTimer()
        process(data)
    }
}

报告内存分配

func BenchmarkMemory(b *testing.B) {
    b.ReportAllocs()
    for i := 0; i < b.N; i++ {
        _ = make([]byte, 1024)
    }
}

并行基准测试

func BenchmarkParallel(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            // 并行执行的代码
            processRequest()
        }
    })
}

性能分析工具

Go 提供了强大的性能分析工具 pprof，可以分析 CPU 和内存使用情况。

CPU 性能分析

import (
    "os"
    "runtime/pprof"
    "testing"
)

func BenchmarkCPUProfile(b *testing.B) {
    f, _ := os.Create("cpu.prof")
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()
    
    for i := 0; i < b.N; i++ {
        doWork()
    }
}

或者使用测试标志：

go test -cpuprofile=cpu.prof -bench=.

内存性能分析

func BenchmarkMemProfile(b *testing.B) {
    for i := 0; i < b.N; i++ {
        doWork()
    }
    
    f, _ := os.Create("mem.prof")
    pprof.WriteHeapProfile(f)
    f.Close()
}

或者：

go test -memprofile=mem.prof -bench=.

使用 pprof 分析

# 交互式分析
go tool pprof cpu.prof

# Web 界面分析
go tool pprof -http=:8080 cpu.prof

# 命令行查看 top
go tool pprof -top cpu.prof

# 查看函数详情
(pprof) list functionName

# 查看调用图
(pprof) web

HTTP 运行时分析

对于运行中的服务，可以启用 HTTP 分析端点：

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

func main() {
    go func() {
        http.ListenAndServe(":6060", nil)
    }()
    
    // 主程序...
}

然后使用 pprof 连接：

# CPU 分析（采样 30 秒）
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 堆内存分析
go tool pprof http://localhost:6060/debug/pprof/heap

# goroutine 分析
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 阻塞分析（需要先启用）
go tool pprof http://localhost:6060/debug/pprof/block

# 互斥锁分析（需要先启用）
go tool pprof http://localhost:6060/debug/pprof/mutex

启用阻塞和互斥分析

import "runtime"

func init() {
    // 启用阻塞分析（采样率为 1，记录所有阻塞事件）
    runtime.SetBlockProfileRate(1)
    
    // 启用互斥锁分析（采样率为 1，记录所有互斥锁事件）
    runtime.SetMutexProfileFraction(1)
}

内存优化

内存分配是 Go 程序性能的关键因素。理解 Go 的内存模型对于优化至关重要。

减少内存分配

每次内存分配都会增加垃圾回收的压力。优化策略包括复用对象和使用指针。

使用 sync.Pool 复用对象：

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func processData(data []byte) string {
    // 从池中获取 buffer
    buf := bufferPool.Get().(*bytes.Buffer)
    buf.Reset()
    defer bufferPool.Put(buf) // 使用完后放回池中
    
    buf.Write(data)
    // 处理...
    return buf.String()
}

避免频繁的字符串拼接：

// 低效：每次拼接都创建新字符串
func badConcat(parts []string) string {
    result := ""
    for _, part := range parts {
        result += part // 每次都分配新内存
    }
    return result
}

// 高效：使用 strings.Builder
func goodConcat(parts []string) string {
    var builder strings.Builder
    for _, part := range parts {
        builder.WriteString(part)
    }
    return builder.String()
}

// 更高效：预分配容量
func betterConcat(parts []string) string {
    // 先计算总长度
    total := 0
    for _, part := range parts {
        total += len(part)
    }
    
    var builder strings.Builder
    builder.Grow(total) // 预分配
    for _, part := range parts {
        builder.WriteString(part)
    }
    return builder.String()
}

切片预分配：

// 低效：频繁扩容
func badAppend(items []int) []int {
    var result []int
    for _, item := range items {
        result = append(result, item*2)
    }
    return result
}

// 高效：预分配容量
func goodAppend(items []int) []int {
    result := make([]int, 0, len(items))
    for _, item := range items {
        result = append(result, item*2)
    }
    return result
}

减少逃逸分析

Go 编译器会进行逃逸分析，决定变量分配在栈上还是堆上。栈分配更快，无需垃圾回收。

// 可能逃逸：返回局部变量的指针
func createSlice() *[]int {
    s := make([]int, 100)
    return &s // s 逃逸到堆
}

// 不逃逸：使用值返回
func createSliceValue() []int {
    s := make([]int, 100)
    return s // 可能不逃逸
}

查看逃逸分析结果：

go build -gcflags="-m"

使用值类型减少分配

对于小型结构体，使用值类型而非指针：

// 小结构体，使用值类型
type Point struct {
    X, Y float64
}

// 计算距离（值接收者）
func (p Point) Distance() float64 {
    return math.Sqrt(p.X*p.X + p.Y*p.Y)
}

// 避免不必要的指针
func processPoints(points []Point) float64 {
    sum := 0.0
    for _, p := range points {
        sum += p.Distance()
    }
    return sum
}

字符串与字节切片转换

字符串和字节切片之间的转换会复制数据：

// 每次转换都复制
str := string(bytes)   // 复制
bytes := []byte(str)   // 复制

// 使用 unsafe 零拷贝转换（谨慎使用）
func unsafeStringToBytes(s string) []byte {
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

func unsafeBytesToString(b []byte) string {
    return unsafe.String(&b[0], len(b))
}

切片优化

切片是 Go 中最常用的数据结构之一，正确使用可以显著提高性能。

预分配容量

// 低效：频繁扩容
var result []int
for i := 0; i < 10000; i++ {
    result = append(result, i)
}

// 高效：预分配
result := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    result = append(result, i)
}

切片表达式性能

// 创建完整切片（复制数据）
newSlice := make([]int, len(oldSlice))
copy(newSlice, oldSlice)

// 切片表达式（共享底层数组）
subSlice := oldSlice[2:5]

// 完整切片表达式（限制容量，防止意外修改）
limitedSlice := oldSlice[2:5:5]

删除元素优化

// 删除中间元素（需要移动后续元素）
func deleteMiddle(s []int, i int) []int {
    return append(s[:i], s[i+1:]...)
}

// 删除不需要保持顺序时，与末尾交换
func deleteUnordered(s []int, i int) []int {
    s[i] = s[len(s)-1]
    return s[:len(s)-1]
}

切片过滤优化

// 低效：创建新切片
func filter(s []int, f func(int) bool) []int {
    var result []int
    for _, v := range s {
        if f(v) {
            result = append(result, v)
        }
    }
    return result
}

// 高效：原地过滤
func filterInPlace(s []int, f func(int) bool) []int {
    n := 0
    for _, v := range s {
        if f(v) {
            s[n] = v
            n++
        }
    }
    return s[:n]
}

Map 优化

预分配容量

// 低效：频繁扩容
m := make(map[int]string)
for i := 0; i < 10000; i++ {
    m[i] = "value"
}

// 高效：预分配
m := make(map[int]string, 10000)

选择合适的键类型

// 小整数作为键更快
m := make(map[int]string)

// 字符串键较慢（需要计算哈希）
m := make(map[string]int)

// 结构体键需要所有字段可比较
type Key struct {
    X, Y int
}
m := make(map[Key]string)

sync.Map 适用场景

sync.Map 适用于特定的并发场景：

var m sync.Map

// 存储
m.Store("key", "value")

// 读取
value, ok := m.Load("key")

// 读取或存储（原子操作）
actual, loaded := m.LoadOrStore("key", "default")

// 删除
m.Delete("key")

// 遍历
m.Range(func(key, value interface{}) bool {
    fmt.Println(key, value)
    return true
})

sync.Map 适用场景：

• 写一次，读多次
• key 集合相对稳定
• 需要并发访问

不适合的场景：

• 频繁写入
• key 集合频繁变化

Go 1.24 Swiss Tables Map 实现

Go 1.24 对内置 map 进行了重大改进，使用 Swiss Tables 作为新的底层实现。这是一个基于瑞士论文的高性能哈希表算法，带来了显著的性能提升。

性能改进：

• CPU 开销平均降低 2-3%
• 对于 disjoint keys 的修改操作，在大型 map 上竞争更少
• 消除了之前实现的"预热"时间

Swiss Tables 的优势：

Swiss Tables（瑞士表）是一种现代哈希表设计，具有以下特点：

1. 更少的内存访问：通过元数据优化，减少缓存未命中
2. 更好的分支预测：使用 SIMD 指令（在支持的平台上）并行探测多个槽位
3. 更低的冲突处理开销：使用线性探测和智能冲突解决策略

实际影响：

// Go 1.24 之前：map 性能在某些场景下有预热问题
// 特别是大 map 的频繁修改

// Go 1.24：直接获得高性能，无需预热
m := make(map[string]int, 100000)
// 性能从第一次访问就是最优的

兼容性说明：

• 完全向后兼容，无需修改代码
• 如果遇到问题，可以通过构建时设置禁用：

  go build -tags=noswissmap
  # 或设置 GOEXPERIMENT=noswissmap

何时禁用 Swiss Tables：

极少数情况下可能需要禁用：

// 如果你的应用对内存布局特别敏感
// 或者依赖特定的 map 迭代顺序（虽然本就不应该依赖）

最佳实践

Go 1.24 的 Swiss Tables 是透明的优化。你不需要修改任何代码，直接升级 Go 版本即可获得性能提升。这是 Go 团队持续优化运行时的一个典型例子。

字符串优化

使用 strings.Builder

// 低效
result := ""
for i := 0; i < n; i++ {
    result += getString(i)
}

// 高效
var builder strings.Builder
builder.Grow(expectedSize) // 预分配
for i := 0; i < n; i++ {
    builder.WriteString(getString(i))
}
result := builder.String()

避免不必要的转换

// 低效：频繁转换
func processStrings(strs []string) []byte {
    var result []byte
    for _, s := range strs {
        result = append(result, []byte(s)...)
    }
    return result
}

// 高效：使用 io.Writer 接口
func processStringsBetter(w io.Writer, strs []string) {
    for _, s := range strs {
        io.WriteString(w, s)
    }
}

函数调用优化

内联小函数

Go 编译器会自动内联简单函数：

// 可能被内联
func add(a, b int) int {
    return a + b
}

// 不会被内联（太复杂）
func complexCalc(a, b int) int {
    // 很多代码...
    return result
}

查看内联决策：

go build -gcflags="-m"

减少函数调用

// 低效：循环内调用函数
for i := 0; i < len(data); i++ {
    process(data[i])
}

// 高效：批处理
processBatch(data)

使用内建函数

// 内建函数通常有特殊优化
len(slice)   // 编译时确定
cap(slice)   // 编译时确定
make([]int, 10)  // 直接分配
copy(dst, src)   // 内部优化

并发优化

goroutine 池

避免创建过多的 goroutine：

// 低效：每个任务一个 goroutine
for _, task := range tasks {
    go process(task)
}

// 高效：使用 worker 池
func workerPool(tasks <-chan Task, results chan<- Result, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for task := range tasks {
                results <- process(task)
            }
        }()
    }
    wg.Wait()
}

使用缓冲 channel

// 无缓冲：发送和接收同步
ch := make(chan int)

// 有缓冲：减少阻塞
ch := make(chan int, 100)

避免 goroutine 泄露

// 可能泄露
func leak() {
    ch := make(chan int)
    go func() {
        ch <- 42 // 如果没有接收者，永远阻塞
    }()
}

// 安全：使用 context 或 done channel
func safe(ctx context.Context) {
    ch := make(chan int, 1)
    go func() {
        select {
        case ch <- 42:
        case <-ctx.Done():
        }
    }()
}

sync.Pool 复用对象

var pool = sync.Pool{
    New: func() interface{} {
        return &MyStruct{}
    },
}

func process() {
    obj := pool.Get().(*MyStruct)
    defer pool.Put(obj)
    
    // 使用 obj...
}

weak.Pointer：弱指针（Go 1.24+）

Go 1.24 引入了 weak.Pointer 类型，这是一种特殊的指针，垃圾回收器在判断对象是否可达时会忽略它。弱指针是构建内存高效数据结构的基础工具。

基本用法：

import "weak"

type Cache struct {
    m sync.Map // map[string]weak.Pointer[Value]
}

func (c *Cache) Get(key string) *Value {
    value, ok := c.m.Load(key)
    if !ok {
        return nil
    }
    
    wp := value.(weak.Pointer[Value])
    // Value() 返回实际指针，如果对象已被回收则返回 nil
    return wp.Value()
}

func (c *Cache) Set(key string, value *Value) {
    // 创建弱指针
    wp := weak.Make(value)
    c.m.Store(key, wp)
}

弱指针的特点：

• 垃圾回收器判断对象可达性时忽略弱指针
• 如果对象仅被弱指针引用，可以被回收
• 弱指针可比较，有稳定的身份
• 适合构建缓存、规范化映射等结构

使用场景：

// 构建内存敏感的缓存
type ValueCache[K comparable, V any] struct {
    create func(K) (*V, error)
    m      sync.Map
}

func (c *ValueCache[K, V]) Get(key K) (*V, error) {
    var newValue *V
    
    for {
        // 尝试从缓存加载
        value, ok := c.m.Load(key)
        if !ok {
            // 缓存未命中，创建新值
            if newValue == nil {
                var err error
                newValue, err = c.create(key)
                if err != nil {
                    return nil, err
                }
            }
            
            // 尝试存入缓存
            wp := weak.Make(newValue)
            value, loaded := c.m.LoadOrStore(key, wp)
            if !loaded {
                // 成功存入，添加清理函数
                runtime.AddCleanup(newValue, func(key K) {
                    c.m.CompareAndDelete(key, wp)
                }, key)
                return newValue, nil
            }
        }
        
        // 检查弱指针是否仍然有效
        if v := value.(weak.Pointer[V]).Value(); v != nil {
            return v, nil
        }
        
        // 弱指针已失效，删除并重试
        c.m.CompareAndDelete(key, value)
    }
}

runtime.AddCleanup：清理函数（Go 1.24+）

Go 1.24 引入了 runtime.AddCleanup 函数，它是 runtime.SetFinalizer 的更现代替代品。相比 Finalizer，AddCleanup 更灵活、更高效、更少出错。

基本用法：

// runtime.AddCleanup(obj, cleanup, arg)
// obj: 要附加清理函数的对象
// cleanup: 清理函数
// arg: 传递给清理函数的参数

type MemoryMappedFile struct {
    data []byte
}

func NewMemoryMappedFile(filename string) (*MemoryMappedFile, error) {
    // ... 创建内存映射 ...
    
    mf := &MemoryMappedFile{data: data}
    
    // 当 mf 不再可达时，自动调用清理函数
    runtime.AddCleanup(mf, func(data []byte) {
        syscall.Munmap(data) // 释放内存映射
    }, data)
    
    return mf, nil
}

与 SetFinalizer 的区别：

特性	SetFinalizer	AddCleanup
清理函数参数	对象本身	独立参数
对象复活	会复活	不会复活
内存回收延迟	至少 2 个 GC 周期	立即可回收
循环引用	导致内存泄露	安全处理
多个清理函数	不支持	支持
附加位置	仅顶层对象	任意指针

为什么 AddCleanup 更好：

1. 不阻止内存回收：清理函数接收独立参数，不引用对象本身，对象可以立即被回收。

2. 安全处理循环引用：

// SetFinalizer 在循环引用时会泄露
// AddCleanup 没有这个问题

type Node struct {
    next *Node
}

func createCycle() {
    a := &Node{}
    b := &Node{}
    a.next = b
    b.next = a  // 循环引用
    
    // AddCleanup 可以安全处理这种情况
    runtime.AddCleanup(a, func() { 
        fmt.Println("a cleaned up") 
    }, nil)
}

3. 支持多个清理函数：

obj := &Resource{}

// 可以添加多个独立的清理函数
runtime.AddCleanup(obj, cleanup1, arg1)
runtime.AddCleanup(obj, cleanup2, arg2)

完整示例：缓存文件句柄：

type FileCache struct {
    files sync.Map // map[string]weak.Pointer[os.File]
}

func (fc *FileCache) Open(filename string) (*os.File, error) {
    // 尝试从缓存获取
    if value, ok := fc.files.Load(filename); ok {
        if f := value.(weak.Pointer[os.File]).Value(); f != nil {
            return f, nil
        }
        // 弱指针已失效，删除旧条目
        fc.files.CompareAndDelete(filename, value)
    }
    
    // 打开文件
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    
    // 创建弱指针并存入缓存
    wp := weak.Make(f)
    fc.files.Store(filename, wp)
    
    // 添加清理函数：当文件对象不可达时从缓存删除
    runtime.AddCleanup(f, func(filename string) {
        fc.files.CompareAndDelete(filename, wp)
    }, filename)
    
    return f, nil
}

注意事项：

1. 清理函数不应该持有对对象的引用（通过闭包捕获或参数传递），否则清理永远不会执行。

2. 清理函数的执行时机不确定，依赖垃圾回收器的行为。

3. 程序退出时清理函数可能不会执行。

JSON 优化

使用流式处理

// 低效：一次性读取全部
data, _ := io.ReadAll(r)
json.Unmarshal(data, &result)

// 高效：流式解码
decoder := json.NewDecoder(r)
decoder.Decode(&result)

使用编码池

var encoderPool = sync.Pool{
    New: func() interface{} {
        return json.NewEncoder(nil)
    },
}

func encodeJSON(w io.Writer, v interface{}) error {
    encoder := encoderPool.Get().(*json.Encoder)
    defer encoderPool.Put(encoder)
    
    encoder.Reset(w)
    return encoder.Encode(v)
}

使用高效 JSON 库

对于高性能场景，考虑使用第三方库：

// 标准库
import "encoding/json"

// 高性能替代品
import jsoniter "github.com/json-iterator/go"
var json = jsoniter.ConfigCompatibleWithStandardLibrary

// 更高性能
import "github.com/bytedance/sonic"

IO 优化

使用缓冲 IO

// 低效：每次读取一个字节
file.Read([]byte{0})

// 高效：使用 bufio
reader := bufio.NewReader(file)
reader.ReadByte()

使用 io.Copy

// 低效：手动复制
buf := make([]byte, 4096)
for {
    n, err := src.Read(buf)
    dst.Write(buf[:n])
    if err != nil {
        break
    }
}

// 高效：使用 io.Copy
io.Copy(dst, src)

预分配缓冲区

// 低效：频繁分配
func readAll(r io.Reader) []byte {
    var buf []byte
    p := make([]byte, 1024)
    for {
        n, _ := r.Read(p)
        buf = append(buf, p[:n]...)
    }
}

// 高效：预分配
func readAllOptimized(r io.Reader) []byte {
    buf := make([]byte, 0, 4096)
    // 或使用 io.ReadAll
    data, _ := io.ReadAll(r)
    return data
}

编译优化

减少二进制大小

# 去除调试信息和符号表
go build -ldflags="-s -w"

# 使用 UPX 压缩（需要安装 UPX）
upx --best myapp

内联控制

# 禁用内联（调试用）
go build -gcflags="-l"

# 调整内联级别
go build -gcflags="-l=2"  # 更积极的内联

逃逸分析

# 查看逃逸分析
go build -gcflags="-m"

# 详细逃逸分析
go build -gcflags="-m=2"

性能优化检查清单

内存分配

• 使用 make 预分配切片和 map 容量
• 使用 strings.Builder 进行字符串拼接
• 使用 sync.Pool 复用临时对象
• 避免在热路径中分配内存
• 检查逃逸分析结果

数据结构

• 选择合适的数据结构（slice vs map vs list）
• 切片预分配容量
• Map 预分配容量
• 考虑内存布局对齐

函数调用

• 减少热路径上的函数调用
• 使用内联优化简单函数
• 避免不必要的 defer（热路径）

并发

• 使用 goroutine 池而非无限创建
• 选择合适的 channel 缓冲大小
• 避免 goroutine 泄露
• 使用 sync.Pool 复用对象

I/O

• 使用缓冲 I/O（bufio）
• 批量读写而非单字节操作
• 使用 io.Copy 而非手动复制

小结

Go 性能优化的关键点：

1. 先测量，后优化：使用基准测试和 pprof 找出瓶颈
2. 减少内存分配：预分配、复用对象、避免逃逸
3. 选择正确的算法和数据结构：这比微优化更重要
4. 合理使用并发：goroutine 池、缓冲 channel
5. 使用专业工具：pprof、trace、benchstat

记住：过早优化是万恶之源。只有在确认性能瓶颈后再进行优化。

练习

1. 为一个排序函数编写基准测试，比较不同实现的性能
2. 使用 pprof 分析一个程序的 CPU 和内存使用
3. 优化一个频繁进行字符串拼接的函数
4. 实现一个高性能的对象池
5. 使用 sync.Pool 优化一个频繁创建临时对象的程序

参考资源

• Go 性能优化官方博客
• Go 诊断工具
• pprof 文档
• High Performance Go