Golang 后端性能优化手册：高级优化技巧

第八章：高级优化技巧

'魔鬼藏在细节中'

8.1 CPU 缓存友好的代码

// 📌 数据结构对齐
// ❌ 结构体字段未对齐，浪费内存
type BadStruct struct {
    a bool // 1 byte + 7 bytes padding
    b int64 // 8 bytes
    c bool // 1 byte + 7 bytes padding
    d int64 // 8 bytes
}
// 总大小：32 bytes

// ✅ 结构体字段对齐，节省内存
type GoodStruct struct {
    b int64 // 8 bytes
    d int64 // 8 bytes
    a bool // 1 byte
    c bool // 1 byte + 6 bytes padding
}
// 总大小：24 bytes，节省 25%

// 📌 利用 CPU 缓存行（Cache Line）
// CPU 缓存行通常是 64 字节
// 避免 False Sharing（伪共享）

// ❌ 伪共享问题
type BadCounter struct {
    count1 int64
    count2 int64 // 与 count1 在同一缓存行
}
var counters BadCounter

func increment1() {
    atomic.AddInt64(&counters.count1, 1)
}

func increment2() {
    atomic.AddInt64(&counters.count2, 1)
}
// 两个 goroutine 分别操作 count1 和 count2，
// 但它们在同一缓存行，导致缓存行频繁失效

// ✅ 使用 padding 避免伪共享
type GoodCounter struct {
    count1 int64
    _pad [56]byte // padding 到 64 字节
    count2 int64
    _pad2 [56]byte
}
// 确保 count1 和 count2 在不同的缓存行

// 📌 顺序访问 vs 随机访问

// ✅ 顺序访问：CPU 缓存友好
func SumSequential(arr []int) int {
    sum := 0
    for i := 0; i < len(arr); i++ {
        sum += arr[i] // 顺序访问，预取效果好
    }
    return sum
}

// ❌ 随机访问：缓存命中率低
func SumRandom(arr []int, indices []int) int {
    sum := 0
    for _, idx := range indices {
        sum += arr[idx] // 随机访问，缓存命中率低
    }
    return sum
}
// 性能差异可达 10 倍以上！

8.2 减少 GC 压力

// 📌 减少堆上分配
// ❌ 逃逸到堆
func CreateUserBad() *User {
    user := User{ID: 1, Name: "test"}
    return &user // 逃逸到堆
}

// ✅ 栈上分配
func CreateUserGood() User {
    return User{ID: 1, Name: "test"} // 在栈上
}

// 使用逃逸分析检查：
// go build -gcflags="-m" main.go

// 📌 复用对象（sync.Pool）
var userPool = sync.Pool{
    New: func() interface{} { return &User{} },
}

func ProcessRequest() {
    user := userPool.Get().(*User)
    defer userPool.Put(user)
    // 使用 user...
}

// 📌 减少指针使用
// ❌ 大量指针增加 GC 扫描时间
type BadNode struct {
    Value *int
    Next *BadNode
}

// ✅ 使用值类型
type GoodNode struct {
    Value int
    Next *GoodNode
}

// 📌 使用 []byte 代替 string
// string 是不可变的，每次修改都会创建新对象

// ❌ 频繁创建 string
func ProcessStringBad(s string) string {
    s = s + "a" // 创建新 string
    s = s + "b" // 又创建新 string
    return s
}

// ✅ 使用 []byte
func ProcessStringGood(s string) string {
    b := []byte(s)
    b = append(b, 'a')
    b = append(b, 'b')
    return string(b)
}

// 📌 控制 GC 频率
func OptimizeGC() {
    // 设置 GC 百分比（默认 100）
    // 当堆增长到上次 GC 后的 2 倍时触发 GC
    debug.SetGCPercent(200)
    // 或者在关键路径前后手动 GC
    runtime.GC()
    // 执行一次 GC
    // 关键业务逻辑...
}

8.3 编译优化

# 📌 编译器优化选项
# 1. 启用内联优化
go build -gcflags="-l=4" main.go
# -l=0: 禁用内联
# -l=1: 默认内联级别
# -l=4: 激进内联

# 2. 开启编译器优化
go build -ldflags="-s -w" main.go
# -s: 去除符号表
# -w: 去除 DWARF 调试信息
# 可减少 30-40% 的二进制大小

# 3. 使用 PGO (Profile-Guided Optimization) Go 1.20+
# 步骤 1：生成 profile
go build -o myapp main.go
./myapp # 运行应用，生成 cpu.pprof

# 步骤 2：使用 profile 编译
go build -pgo=cpu.pprof -o myapp main.go
# 性能提升 5-15%

# 4. 交叉编译优化
GOOS=linux GOARCH=amd64 go build -o myapp main.go

// 📌 使用编译器指令
// 内联指示
//go:inline
func fastFunction() int {
    return 42
}

// 禁止内联
//go:noinline
func slowFunction() int {
    return 42
}

// 无逃逸检查
//go:noescape
func noescape(p *int)

// 禁止边界检查
func sumArray(arr []int) int {
    sum := 0
    for i := 0; i < len(arr); i++ {
        sum += arr[i] // 编译器会插入边界检查
    }
    return sum
}

// 使用 unsafe 去除边界检查（谨慎使用！）
func sumArrayUnsafe(arr []int) int {
    sum := 0
    for i := 0; i < len(arr); i++ {
        // 手动保证不越界
        sum += arr[i]
    }
    return sum
}

8.4 性能测试与压测

// 📌 基准测试
func BenchmarkStringConcat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := ""
        for j := 0; j < 100; j++ {
            s += "test"
        }
    }
}

func BenchmarkStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var builder strings.Builder
        builder.Grow(400)
        for j := 0; j < 100; j++ {
            builder.WriteString("test")
        }
        _ = builder.String()
    }
}

// 运行基准测试：
// go test -bench=. -benchmem
//
// 输出示例：
// BenchmarkStringConcat-8 20000 50000 ns/op 100000 B/op 100 allocs/op
// BenchmarkStringBuilder-8 200000 6000 ns/op 512 B/op 1 allocs/op

// 📌 压力测试
// 使用 hey 工具
// hey -n 10000 -c 100 http://localhost:8080/api/users
// -n: 总请求数
// -c: 并发数

// 使用 wrk 工具
// wrk -t12 -c400 -d30s http://localhost:8080/api/users
// -t: 线程数
// -c: 并发连接数
// -d: 测试持续时间

// 使用 ab 工具
// ab -n 10000 -c 100 http://localhost:8080/api/users

// 📌 使用 Go 编写压测工具
func StressTest(url string, concurrent, requests int) {
    var wg sync.WaitGroup
    start := time.Now()
    perWorker := requests / concurrent
    for i := 0; i < concurrent; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < perWorker; j++ {
                resp, err := http.Get(url)
                if err == nil {
                    resp.Body.Close()
                }
            }
        }()
    }
    wg.Wait()
    duration := time.Since(start)
    fmt.Printf("完成 %d 个请求，耗时 %v\n", requests, duration)
    fmt.Printf("QPS: %.2f\n", float64(requests)/duration.Seconds())
}