Go 服务性能优化实战：从 pprof 分析到落地方案

# 1. 在代码中启用 pprof
import _ "net/http/pprof"

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

# 2. 采集不同类型的 profile
# CPU profile (30秒采样)
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 当前内存使用
go tool pprof http://localhost:6060/debug/pprof/heap

# 历史内存分配
go tool pprof -alloc_space http://localhost:6060/debug/pprof/heap

# 对象数量
go tool pprof -alloc_objects http://localhost:6060/debug/pprof/heap

// ❌ 每次请求都创建新连接
func CallRemoteService(ctx context.Context) error {
    conn, err := grpc.Dial("remote-service:9000")
    if err != nil {
        return err
    }
    defer conn.Close()
    
    client := pb.NewServiceClient(conn)
    resp, err := client.DoSomething(ctx, &pb.Request{})
    // ...
}

// ✅ 使用连接池
type ClientPool struct {
    pool sync.Map // key: address, value: *grpc.ClientConn
    mu   sync.RWMutex
}

func (p *ClientPool) GetClient(address string) (*grpc.ClientConn, error) {
    // 1. 尝试从池中获取
    if conn, ok := p.pool.Load(address); ok {
        return conn.(*grpc.ClientConn), nil
    }
    
    // 2. 加锁创建新连接
    p.mu.Lock()
    defer p.mu.Unlock()
    
    // Double-check：可能其他 goroutine 已创建
    if conn, ok := p.pool.Load(address); ok {
        return conn.(*grpc.ClientConn), nil
    }
    
    // 3. 创建新连接
    conn, err := grpc.Dial(address,
        grpc.WithDefaultCallOptions(
            grpc.MaxCallRecvMsgSize(10*1024*1024),
        ),
        grpc.WithKeepaliveParams(keepalive.ClientParameters{
            Time:                10 * time.Second,
            Timeout:             3 * time.Second,
            PermitWithoutStream: true,
        }),
    )
    if err != nil {
        return nil, err
    }
    
    // 4. 存入池中
    p.pool.Store(address, conn)
    return conn, nil
}

// 使用
var globalPool = &ClientPool{}

func CallRemoteService(ctx context.Context) error {
    conn, err := globalPool.GetClient("remote-service:9000")
    if err != nil {
        return err
    }
    
    client := pb.NewServiceClient(conn)
    resp, err := client.DoSomething(ctx, &pb.Request{})
    // ... 连接不关闭，继续复用
}

// 调用监控系统 API
http.Get("http://monitor-service/api/metrics")

// 调用认证系统 API  
http.Get("http://auth-service/api/verify")

// 调用通知系统 API
http.Post("http://notify-service/api/send")

resp, err := http.DefaultClient.Get(url)

MaxIdleConnsPerHost: 2  // 🔴 每个主机只保持 2 个空闲连接

var DefaultTransport = &http.Transport{
    MaxIdleConns:          100,  // 全局最多 100 个空闲连接
    MaxIdleConnsPerHost:   2,    // ❌ 每个主机只保持 2 个！
    IdleConnTimeout:       90 * time.Second,
}

// 创建优化的 HTTP Client
var OptimizedHTTPClient = &http.Client{
    Transport: &http.Transport{
        // 🔥 核心配置：连接池大小
        MaxIdleConns:        100,  // 全局最多 100 个空闲连接
        MaxIdleConnsPerHost: 20,   // ✅ 每个主机 20 个（从 2 提升到 20）
        MaxConnsPerHost:     100,  // 每个主机最多 100 个连接
        IdleConnTimeout:     90 * time.Second,
        
        // 连接建立超时
        DialContext: (&net.Dialer{
            Timeout:   10 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        
        // TLS 配置
        TLSHandshakeTimeout: 10 * time.Second,
        
        // 其他优化
        ForceAttemptHTTP2:       true,  // 使用 HTTP/2
        ResponseHeaderTimeout:   30 * time.Second,
        ExpectContinueTimeout:   1 * time.Second,
    },
    Timeout: 60 * time.Second,
}

// 使用优化的 Client
func MakeRequest(url string) ([]byte, error) {
    resp, err := OptimizedHTTPClient.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}

// 在 HTTP 请求处理函数中
func DoRequest(url string) error {
    header := make(http.Header)  // 👈 每次都 make
    header.Set("Content-Type", "application/json")
    header.Set("Authorization", "Bearer token")
    // ... 使用
    // 函数结束，header 被 GC 回收
}

go tool pprof -gc http://localhost:6060/debug/pprof/heap

GC次数：200次/分钟
GC暂停：平均 10ms

// ❌ 每次请求都创建新的 Header
func HandleRequest(w http.ResponseWriter, r *http.Request) {
    header := make(http.Header)  // 创建 map
    header.Set("Content-Type", "application/json")
    // ... 使用完就不管了
    // GC 需要回收这个 header
}

// 高并发场景（100 QPS）：
// - 每秒创建 100 个 map
// - 每秒销毁 100 个 map
// - GC 压力大

// 创建对象池（全局创建一次）
var headerPool = sync.Pool{
    New: func() interface{} {
        // 只在池子空的时候才创建
        return make(http.Header, 8)
    },
}

// ✅ 使用对象池
func HandleRequest(w http.ResponseWriter, r *http.Request) {
    // 1. 从池子里"借"一个 Header
    header := headerPool.Get().(http.Header)
    
    // 2. 用完后记得"还回去"
    defer func() {
        // 清空内容
        for k := range header {
            delete(header, k)
        }
        // 放回池子
        headerPool.Put(header)
    }()
    
    // 3. 正常使用
    header.Set("Content-Type", "application/json")
    // ...
}

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

func ProcessData(data []byte) []byte {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufferPool.Put(buf)
    }()
    
    buf.Write(data)
    // ... 处理
    return buf.Bytes()
}

// 2. 切片池
var slicePool = sync.Pool{
    New: func() interface{} {
        s := make([]byte, 0, 1024)
        return &s
    },
}

// 3. 结构体池
var requestPool = sync.Pool{
    New: func() interface{} {
        return &Request{}
    },
}

// ✅ 正确做法
obj := pool.Get()
defer func() {
    // 1️⃣ 必须清空！
    obj.Reset()
    // 2️⃣ 归还
    pool.Put(obj)
}()

// ❌ 错误做法 1：忘记清空
defer pool.Put(obj)  // 下次取出来会有旧数据

// ❌ 错误做法 2：忘记归还
obj := pool.Get()
// 用完忘了 Put，池子会越来越空

func ProcessBatch(items []Item) {
    for _, item := range items {
        go func(i Item) {  // 👈 每个 item 一个 goroutine
            process(i)
        }(item)
    }
}

// ❌ 为每个请求创建 goroutine
func ProcessBatch(items []Item) {
    for _, item := range items {
        go func(i Item) {
            // 处理单个 item
            process(i)
        }(item)
    }
}

// 问题：
// - 如果有 10000 个 items，就创建 10000 个 goroutine
// - 大量的调度开销
// - 可能耗尽系统资源

// ✅ 使用 Worker Pool
func ProcessBatch(items []Item) error {
    // 创建任务队列
    taskCh := make(chan Item, len(items))
    resultCh := make(chan error, len(items))
    
    // 启动固定数量的 worker（如 10 个）
    workerCount := 10
    for i := 0; i < workerCount; i++ {
        go worker(taskCh, resultCh)
    }
    
    // 发送任务
    for _, item := range items {
        taskCh <- item
    }
    close(taskCh)
    
    // 收集结果
    for range items {
        if err := <-resultCh; err != nil {
            return err
        }
    }
    return nil
}

func worker(tasks <-chan Item, results chan<- error) {
    for item := range tasks {
        err := process(item)
        results <- err
    }
}

import "golang.org/x/sync/errgroup"

// ✅ 使用 errgroup.SetLimit
func ProcessBatch(ctx context.Context, items []Item) error {
    g, ctx := errgroup.WithContext(ctx)
    
    // 🔥 限制并发数为 10
    g.SetLimit(10)
    
    for _, item := range items {
        item := item  // 捕获循环变量
        g.Go(func() error {
            return process(ctx, item)
        })
    }
    
    return g.Wait()
}

import "golang.org/x/sync/semaphore"

// ✅ 使用信号量控制并发
func ProcessBatch(ctx context.Context, items []Item) error {
    // 最多 10 个并发
    sem := semaphore.NewWeighted(10)
    
    for _, item := range items {
        // 获取信号量（阻塞直到可用）
        if err := sem.Acquire(ctx, 1); err != nil {
            return err
        }
        
        go func(i Item) {
            defer sem.Release(1)  // 释放信号量
            process(i)
        }(item)
    }
    
    // 等待所有 goroutine 完成
    if err := sem.Acquire(ctx, 10); err != nil {
        return err
    }
    return nil
}

import (
    "github.com/prometheus/client_golang/prometheus"
)

var (
    // 请求延迟
    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "request_duration_seconds",
            Help:    "Request duration in seconds",
            Buckets: []float64{0.001, 0.01, 0.1, 1, 10},
        },
        []string{"method", "status"},
    )
    
    // 活跃连接数
    activeConnections = prometheus.NewGauge(
        prometheus.GaugeOpts{
            Name: "active_connections",
            Help: "Number of active connections",
        },
    )
    
    // GC 统计
    gcDuration = prometheus.NewHistogram(
        prometheus.HistogramOpts{
            Name:    "gc_duration_seconds",
            Help:    "GC duration in seconds",
            Buckets: prometheus.DefBuckets,
        },
    )
)

# 优化前采集
go tool pprof -http=:8080 http://localhost:6060/debug/pprof/heap

# 优化后采集
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/heap

# 对比关键指标：
# 1. syscall.Syscall6 占比（期望降低 50%+）
# 2. net.(*Transport).dialConn 占比（期望降低 80%+）
# 3. textproto.MIMEHeader.Set 占比（期望降低 50%+）
# 4. 总的 alloc_objects 数量（期望降低 30-50%）

# 使用 hey 进行压测
hey -n 10000 -c 100 -m POST \
  -H "Content-Type: application/json" \
  -d '{"key":"value"}' \
  http://localhost:8080/api/endpoint

# 关注指标：
# - Requests/sec（期望提升 30-50%）
# - Average latency（期望降低 20-30%）
# - 99% latency（期望降低 30-40%）

// 1. 连接复用
// ❌ 每次创建新连接
// ✅ 使用连接池

// 2. 对象复用
// ❌ 频繁 make/new
// ✅ 使用 sync.Pool

// 3. 预分配容量
// ❌ slice = append(slice, item)
// ✅ slice := make([]T, 0, expectedSize)

// 4. 并发控制
// ❌ 无限制创建 goroutine
// ✅ Worker Pool / errgroup.SetLimit

// 5. 减少锁竞争
// ❌ 全局大锁
// ✅ 细粒度锁 / atomic / lock-free

// 6. 减少内存拷贝
// ❌ 大对象值传递
// ✅ 指针传递

// 7. 字符串拼接
// ❌ s = s + str (n²复杂度)
// ✅ strings.Builder / bytes.Buffer