GolangRPC调用超时与重试策略实现

context

context.Context

context

context

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
    pb "your_project/proto" // 假设你有一个proto文件定义了服务
)

// 模拟一个RPC客户端
type MyServiceClient struct {
    client pb.MyServiceClient
    conn   *grpc.ClientConn
}

func NewMyServiceClient(addr string) (*MyServiceClient, error) {
    conn, err := grpc.Dial(addr, grpc.WithInsecure()) // 生产环境请使用grpc.WithTransportCredentials
    if err != nil {
        return nil, fmt.Errorf("did not connect: %v", err)
    }
    return &MyServiceClient{
        client: pb.NewMyServiceClient(conn),
        conn:   conn,
    }, nil
}

func (s *MyServiceClient) Close() error {
    return s.conn.Close()
}

// CallWithTimeoutAndRetry 封装了带超时和重试的RPC调用
func (s *MyServiceClient) CallWithTimeoutAndRetry(
    ctx context.Context,
    request *pb.MyRequest,
    initialTimeout time.Duration,
    maxRetries int,
    backoffStrategy func(int) time.Duration,
) (*pb.MyResponse, error) {
    var resp *pb.MyResponse
    var err error

    for i := 0; i <= maxRetries; i++ {
        // 每次重试都创建一个新的context，避免前一次重试的context已过期
        callCtx, cancel := context.WithTimeout(ctx, initialTimeout)
        defer cancel() // 确保context被取消，释放资源

        resp, err = s.client.SomeMethod(callCtx, request)
        if err == nil {
            return resp, nil // 成功，直接返回
        }

        // 检查错误类型，判断是否值得重试
        st, ok := status.FromError(err)
        if !ok {
            // 非gRPC错误，可能是一些网络层面的问题，通常可以重试
            log.Printf("Non-gRPC error during attempt %d: %v", i+1, err)
        } else {
            switch st.Code() {
            case codes.DeadlineExceeded, codes.Unavailable, codes.ResourceExhausted:
                log.Printf("RPC failed with code %s on attempt %d: %v", st.Code(), i+1, err)
                // 这些错误通常是暂时的，值得重试
            case codes.Internal, codes.Unknown:
                // 内部错误或未知错误，也可能值得重试，但要小心
                log.Printf("RPC failed with code %s on attempt %d: %v", st.Code(), i+1, err)
            default:
                // 其他错误（如InvalidArgument, PermissionDenied等）通常表示请求本身有问题，不应重试
                log.Printf("RPC failed with non-retryable code %s on attempt %d: %v", st.Code(), i+1, err)
                return nil, err
            }
        }

        if i < maxRetries {
            // 计算退避时间并等待
            sleepDuration := backoffStrategy(i)
            log.Printf("Retrying in %v...", sleepDuration)
            select {
            case <-time.After(sleepDuration):
                // 继续下一次重试
            case <-ctx.Done():
                // 外部context被取消，停止重试
                return nil, ctx.Err()
            }
        }
    }

    return nil, fmt.Errorf("RPC failed after %d retries: %w", maxRetries, err)
}

// 示例退避策略：指数退避
func ExponentialBackoff(attempt int) time.Duration {
    baseDelay := 100 * time.Millisecond
    maxDelay := 5 * time.Second
    delay := baseDelay * time.Duration(1<<attempt)
    if delay > maxDelay {
        return maxDelay
    }
    return delay
}

// main函数中如何使用
func main() {
    // 假设你的gRPC服务运行在:50051
    client, err := NewMyServiceClient("localhost:50051")
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }
    defer client.Close()

    // 外部context，可以用来控制整个操作的生命周期
    parentCtx := context.Background() // 或者 context.WithTimeout(context.Background(), 30*time.Second)

    request := &pb.MyRequest{Message: "Hello, RPC!"}
    initialCallTimeout := 2 * time.Second // 每次RPC调用的超时时间
    maxRetries := 3                       // 最大重试次数

    resp, err := client.CallWithTimeoutAndRetry(
        parentCtx,
        request,
        initialCallTimeout,
        maxRetries,
        ExponentialBackoff,
    )

    if err != nil {
        log.Printf("Final RPC call failed: %v", err)
    } else {
        log.Printf("Final RPC call successful: %s", resp.GetResponse())
    }
}

your_project/proto

proto

protoc

pb.MyServiceClient

pb.MyRequest

pb.MyResponse

pb.SomeMethod

proto

context.WithTimeout

context

net

net.Dialer

Timeout

grpc.WithDialOption(grpc.WithBlock(), grpc.WithTimeout(connTimeout))

context

net.Conn

http.Client

http.Client

Timeout