Engineering

性能优化实战：让你的 Go 应用飞起来

学习 Go 应用性能优化的实战技巧，包括 CPU、内存、I/O 优化和性能分析工具的使用

Leeting Yan 2021-05-29 4 分钟阅读 1907 字

性能优化实战：让你的 Go 应用飞起来

Go 语言本身性能优秀，但不当的编码方式仍会导致性能问题。本文将介绍如何通过分析和优化，让你的 Go 应用达到最佳性能。

性能优化原则

在开始优化之前，记住以下原则：

先测量，后优化：不要凭直觉优化
关注热点：优化 20% 的代码解决 80% 的问题
避免过早优化：先让代码工作，再让它快
保持简单：不要为了性能牺牲可读性

性能分析工具

pprof

Go 内置的性能分析工具：

package main

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

func main() {
    // 启用 pprof
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
    
    // 你的应用
    runApplication()
}

使用方式：

# 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=:8080 cpu.prof

基准测试

package main

import (
    "testing"
)

func BenchmarkStringConcat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := ""
        for j := 0; j < 100; j++ {
            s += "x"
        }
    }
}

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

运行基准测试：

go test -bench=. -benchmem -benchtime=3s

CPU 优化

1. 减少内存分配

// ❌ 不好：频繁分配
func processItems(items []Item) []Result {
    results := make([]Result, 0)
    for _, item := range items {
        result := processItem(item)
        results = append(results, result)
    }
    return results
}

// ✅ 好：预分配容量
func processItems(items []Item) []Result {
    results := make([]Result, 0, len(items))
    for _, item := range items {
        result := processItem(item)
        results = append(results, result)
    }
    return results
}

2. 对象池

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

func processRequest(data []byte) error {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufferPool.Put(buf)
    }()
    
    // 使用 buf 处理数据
    buf.Write(data)
    // ...
    
    return nil
}

3. 避免字符串拼接

// ❌ 慢：每次拼接都分配新字符串
func buildString(parts []string) string {
    result := ""
    for _, part := range parts {
        result += part
    }
    return result
}

// ✅ 快：使用 strings.Builder
func buildString(parts []string) string {
    var builder strings.Builder
    builder.Grow(calculateTotalLength(parts))
    for _, part := range parts {
        builder.WriteString(part)
    }
    return builder.String()
}

// ✅ 快：使用 strings.Join
func buildString(parts []string) string {
    return strings.Join(parts, "")
}

4. 并行处理

func processInParallel(items []Item, workers int) []Result {
    results := make([]Result, len(items))
    var wg sync.WaitGroup
    
    chunkSize := (len(items) + workers - 1) / workers
    
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func(start int) {
            defer wg.Done()
            end := start + chunkSize
            if end > len(items) {
                end = len(items)
            }
            for j := start; j < end; j++ {
                results[j] = processItem(items[j])
            }
        }(i * chunkSize)
    }
    
    wg.Wait()
    return results
}

内存优化

1. 减少 GC 压力

// ❌ 不好：创建大量临时对象
func processRequest(req *Request) *Response {
    data := fetchData(req.ID)        // 分配
    validated := validate(data)       // 分配
    transformed := transform(validated) // 分配
    return buildResponse(transformed)   // 分配
}

// ✅ 好：复用对象
type RequestContext struct {
    Data        []byte
    Validated   []byte
    Transformed []byte
    Response    Response
}

var contextPool = sync.Pool{
    New: func() interface{} {
        return &RequestContext{
            Data:        make([]byte, 0, 4096),
            Validated:   make([]byte, 0, 4096),
            Transformed: make([]byte, 0, 4096),
        }
    },
}

func processRequest(req *Request) *Response {
    ctx := contextPool.Get().(*RequestContext)
    defer func() {
        ctx.Data = ctx.Data[:0]
        ctx.Validated = ctx.Validated[:0]
        ctx.Transformed = ctx.Transformed[:0]
        contextPool.Put(ctx)
    }()
    
    ctx.Data = fetchData(req.ID, ctx.Data)
    ctx.Validated = validate(ctx.Data, ctx.Validated)
    ctx.Transformed = transform(ctx.Validated, ctx.Transformed)
    return buildResponse(ctx.Transformed, &ctx.Response)
}

2. 使用 []byte 替代 string

// ❌ 不好：字符串不可变，每次修改都分配
func processString(s string) string {
    s = strings.Replace(s, "old", "new", -1)
    s = strings.ToUpper(s)
    return s
}

// ✅ 好：字节切片可变
func processBytes(b []byte) []byte {
    bytes.Replace(b, []byte("old"), []byte("new"), -1)
    bytes.ToUpper(b)
    return b
}

3. 避免切片扩容

// ❌ 不好：频繁扩容
func filter(items []Item) []Item {
    result := []Item{}
    for _, item := range items {
        if item.Valid {
            result = append(result, item)
        }
    }
    return result
}

// ✅ 好：预分配
func filter(items []Item) []Item {
    result := make([]Item, 0, len(items))
    for _, item := range items {
        if item.Valid {
            result = append(result, item)
        }
    }
    return result
}

I/O 优化

1. 使用缓冲 I/O

// ❌ 不好：每次写入都系统调用
func writeLines(file *os.File, lines []string) error {
    for _, line := range lines {
        _, err := file.WriteString(line + "\n")
        if err != nil {
            return err
        }
    }
    return nil
}

// ✅ 好：使用缓冲
func writeLines(file *os.File, lines []string) error {
    writer := bufio.NewWriter(file)
    defer writer.Flush()
    
    for _, line := range lines {
        _, err := writer.WriteString(line + "\n")
        if err != nil {
            return err
        }
    }
    return nil
}

2. 批量数据库操作

// ❌ 不好：逐条插入
func insertUsers(db *sql.DB, users []User) error {
    for _, user := range users {
        _, err := db.Exec("INSERT INTO users (name, email) VALUES (?, ?)",
            user.Name, user.Email)
        if err != nil {
            return err
        }
    }
    return nil
}

// ✅ 好：批量插入
func insertUsers(db *sql.DB, users []User) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()
    
    stmt, err := tx.Prepare("INSERT INTO users (name, email) VALUES (?, ?)")
    if err != nil {
        return err
    }
    defer stmt.Close()
    
    for _, user := range users {
        _, err = stmt.Exec(user.Name, user.Email)
        if err != nil {
            return err
        }
    }
    
    return tx.Commit()
}

3. HTTP 连接池

var httpClient = &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        100,
        MaxIdleConnsPerHost: 100,
        IdleConnTimeout:     90 * time.Second,
        TLSHandshakeTimeout: 10 * time.Second,
    },
    Timeout: 30 * time.Second,
}

func callAPI(url string) error {
    resp, err := httpClient.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    // 处理响应
    return nil
}

并发优化

1. 控制并发数量

func processWithLimit(items []Item, maxWorkers int) []Result {
    results := make([]Result, len(items))
    sem := make(chan struct{}, maxWorkers)
    var wg sync.WaitGroup
    
    for i, item := range items {
        wg.Add(1)
        go func(idx int, it Item) {
            defer wg.Done()
            sem <- struct{}{}        // 获取信号量
            defer func() { <-sem }() // 释放信号量
            
            results[idx] = processItem(it)
        }(i, item)
    }
    
    wg.Wait()
    return results
}

2. Worker Pool

type WorkerPool struct {
    tasks   chan Task
    results chan Result
    workers int
}

func NewWorkerPool(workers int) *WorkerPool {
    return &WorkerPool{
        tasks:   make(chan Task, 100),
        results: make(chan Result, 100),
        workers: workers,
    }
}

func (p *WorkerPool) Start() {
    for i := 0; i < p.workers; i++ {
        go func() {
            for task := range p.tasks {
                result := processTask(task)
                p.results <- result
            }
        }()
    }
}

func (p *WorkerPool) Submit(task Task) {
    p.tasks <- task
}

func (p *WorkerPool) Results() <-chan Result {
    return p.results
}

缓存优化

1. 本地缓存

type Cache struct {
    mu    sync.RWMutex
    items map[string]*CacheItem
}

type CacheItem struct {
    Value     interface{}
    ExpiresAt time.Time
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    item, ok := c.items[key]
    c.mu.RUnlock()
    
    if !ok || time.Now().After(item.ExpiresAt) {
        return nil, false
    }
    
    return item.Value, true
}

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
    c.mu.Lock()
    c.items[key] = &CacheItem{
        Value:     value,
        ExpiresAt: time.Now().Add(ttl),
    }
    c.mu.Unlock()
}

2. 缓存击穿防护

type singleflightGroup struct {
    mu sync.Mutex
    m  map[string]*call
}

type call struct {
    wg  sync.WaitGroup
    val interface{}
    err error
}

func (g *singleflightGroup) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
    g.mu.Lock()
    if g.m == nil {
        g.m = make(map[string]*call)
    }
    
    if c, ok := g.m[key]; ok {
        g.mu.Unlock()
        c.wg.Wait()
        return c.val, c.err
    }
    
    c := new(call)
    c.wg.Add(1)
    g.m[key] = c
    g.mu.Unlock()
    
    c.val, c.err = fn()
    c.wg.Done()
    
    g.mu.Lock()
    delete(g.m, key)
    g.mu.Unlock()
    
    return c.val, c.err
}

// 使用
var sf singleflightGroup

func getUser(id int) (*User, error) {
    key := fmt.Sprintf("user:%d", id)
    
    val, err := sf.Do(key, func() (interface{}, error) {
        // 从数据库加载
        return loadUserFromDB(id)
    })
    
    if err != nil {
        return nil, err
    }
    
    return val.(*User), nil
}

性能优化清单

## CPU 优化
- [ ] 减少内存分配
- [ ] 使用对象池
- [ ] 避免字符串拼接
- [ ] 并行处理

## 内存优化
- [ ] 减少 GC 压力
- [ ] 使用 []byte 替代 string
- [ ] 避免切片扩容
- [ ] 复用对象

## I/O 优化
- [ ] 使用缓冲 I/O
- [ ] 批量数据库操作
- [ ] HTTP 连接池
- [ ] 异步 I/O

## 并发优化
- [ ] 控制并发数量
- [ ] Worker Pool
- [ ] 避免锁竞争
- [ ] 使用 channel

## 缓存优化
- [ ] 本地缓存
- [ ] 分布式缓存
- [ ] 缓存击穿防护
- [ ] 合理的过期策略

总结

性能优化是一个持续的过程：

分析：使用 pprof 找出热点
优化：针对热点进行优化
验证：通过基准测试验证效果
迭代：持续改进

关键要点：

先测量，后优化
关注热点，不要过早优化
保持代码简单可读
使用合适的工具和技术

记住：过早优化是万恶之源，但没有优化是性能问题的根源。

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章返回首页

性能优化实战：让你的 Go 应用飞起来

性能优化原则

性能分析工具

pprof

基准测试

CPU 优化

1. 减少内存分配

2. 对象池

3. 避免字符串拼接

4. 并行处理

内存优化

1. 减少 GC 压力

2. 使用 []byte 替代 string

3. 避免切片扩容

I/O 优化

1. 使用缓冲 I/O

2. 批量数据库操作

3. HTTP 连接池

并发优化

1. 控制并发数量

2. Worker Pool

缓存优化

1. 本地缓存

2. 缓存击穿防护

性能优化清单

总结

推荐资源

探索更多技术文章