性能优化

本章介绍 gRPC 的性能优化技巧，帮助构建高性能的 gRPC 服务。

性能优化概述

gRPC 本身已经具备良好的性能基础，但仍可以通过合理的配置和优化进一步提升性能。

连接优化

连接复用

最佳实践：复用连接而非每次创建新连接。

// 推荐：使用全局连接
var globalConn *grpc.ClientConn

func getClient() (*grpc.ClientConn, error) {
    if globalConn != nil {
        return globalConn, nil
    }
    
    conn, err := grpc.Dial("localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()),
        grpc.WithBlock(),
    )
    if err != nil {
        return nil, err
    }
    globalConn = conn
    return globalConn, nil
}

连接池配置

对于高并发场景，合理配置连接参数：

conn, err := grpc.Dial(
    "localhost:50051",
    grpc.WithTransportCredentials(insecure.NewCredentials()),
    // 连接保活
    grpc.WithKeepaliveParams(keepalive.ClientParameters{
        Time:                10 * time.Second,
        Timeout:             time.Second,
        PermitWithoutStream: true,
    }),
    // 最大消息大小
    grpc.WithDefaultCallOptions(
        grpc.MaxCallRecvMsgSize(10*1024*1024),
    ),
)

消息优化

消息大小控制

避免传输过大的消息，建议：

• 单个消息控制在 1-4MB 以内
• 大数据使用流式传输

压缩配置

启用消息压缩减少传输量：

import "google.golang.org/grpc/encoding/gzip"

// 客户端启用压缩
conn, err := grpc.Dial("localhost:50051",
    grpc.WithTransportCredentials(insecure.NewCredentials()),
    grpc.WithDefaultCallOptions(grpc.UseCompressor(gzip.Name)),
)

流式处理优化

流量控制

合理使用流式传输，避免内存溢出：

func (s *server) StreamData(req *pb.Request, stream pb.Service_StreamDataServer) error {
    // 分批发送，避免内存占用过大
    batchSize := 100
    for i := 0; i < totalItems; i += batchSize {
        items := getBatch(i, batchSize)
        for _, item := range items {
            if err := stream.Send(item); err != nil {
                return err
            }
        }
        // 检查客户端是否仍然存活
        if stream.Context().Err() != nil {
            return stream.Context().Err()
        }
    }
    return nil
}

并发处理

使用 goroutine 处理并发请求：

func (s *server) ProcessItems(stream pb.Service_ProcessItemsServer) error {
    var wg sync.WaitGroup
    errCh := make(chan error, 1)
    
    for {
        item, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }
        
        wg.Add(1)
        go func(item *pb.Item) {
            defer wg.Done()
            if err := processItem(item); err != nil {
                select {
                case errCh <- err:
                default:
                }
            }
        }(item)
    }
    
    wg.Wait()
    close(errCh)
    
    if err := <-errCh; err != nil {
        return err
    }
    
    return stream.SendAndClose(&pb.Result{Success: true})
}

监控和调优

性能指标监控

import "google.golang.org/grpc/credentials/insecure"

func monitorConnection(conn *grpc.ClientConn) {
    state := conn.GetState()
    log.Printf("连接状态: %s", state)
}

服务器监控

func (s *server) startMetricsServer() {
    http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
        // 返回 Prometheus 格式的指标
        fmt.Fprintf(w, "# HELP grpc_server_connections 当前连接数\n")
        fmt.Fprintf(w, "# TYPE grpc_server_connections gauge\n")
        fmt.Fprintf(w, "grpc_server_connections %d\n", s.activeConnections)
    })
    http.ListenAndServe(":9090", nil)
}

最佳实践总结

1. 复用连接：避免频繁创建和销毁连接
2. 合理设置超时：根据业务场景设置合适的超时时间
3. 使用流式传输：处理大数据时使用流式传输
4. 监控指标：监控关键性能指标，及时发现瓶颈
5. 资源限制：设置消息大小限制，防止资源耗尽

小结

本章介绍了 gRPC 性能优化的主要方法：

• 连接复用和配置
• 消息大小和压缩优化
• 流式传输优化
• 并发处理技巧
• 监控和调优方法

根据实际业务场景选择合适的优化策略，平衡性能和资源消耗。