【Golang教程】gRPC进阶教程服务超时设置详解

所需工具：

Go语言/Golang

聪明的大脑

勤劳的双手

注意：本站只提供教程，不提供任何成品+工具+软件链接，仅限用于学习和研究，禁止商业用途，未经允许禁止转载/分享等

教程如下

前言

gRPC默认的请求的超时时间是很长的，当你没有设置请求超时时间时，所有在运行的请求都占用大量资源且可能运行很长的时间，导致服务资源损耗过高，使得后来的请求响应过慢，甚至会引起整个进程崩溃。

为了避免这种情况，我们的服务应该设置超时时间。

前面的入门教程

Go gRPC环境安装教程示例详解

Go gRPC教程实现Simple RPC

Go gRPC服务端流式RPC教程示例

Go gRPC服务客户端流式RPC教程

Go gRPC服务双向流式RPC教程

提到当客户端发起请求时候，需要传入上下文context.Context，用于结束超时或取消的请求。

本篇以简单RPC为例，介绍如何设置gRPC请求的超时时间。

客户端请求设置超时时间

修改调用服务端方法

1.把超时时间设置为当前时间+3秒

 	     clientDeadline := time.Now().Add(time.Duration(3 * time.Second))
 	     ctx, cancel := context.WithDeadline(ctx, clientDeadline)
 	     defer cancel()

2.响应错误检测中添加超时检测

 	         // 传入超时时间为3秒的ctx
 	     res, err := grpcClient.Route(ctx, & req)
 	     if err != nil {
 	         //获取错误状态
 	         statu, ok := status.FromError(err)
 	         if ok {
 	             //判断是否为调用超时
 	             if statu.Code() == codes.DeadlineExceeded {
 	                 log.Fatalln("Route timeout!")
 	             }
 	         }
 	         log.Fatalf("Call Route err: %v", err)
 	     }
 	     // 打印返回值
 	     log.Println(res.Value)

完整的client.go代码

 	package main
 	import (
 	     "context"
 	     "log"
 	     "time"
 	     "google.golang.org/grpc"
 	     "google.golang.org/grpc/codes"
 	     "google.golang.org/grpc/status"
 	     pb "go-grpc-example/6-grpc_deadlines/proto"
 	)
 	// Address 连接地址
 	const Address string = ":8000"
 	var grpcClient pb.SimpleClient
 	func main() {
 	     // 连接服务器
 	     conn, err := grpc.Dial(Address, grpc.WithInsecure())
 	     if err != nil {
 	         log.Fatalf("net.Connect err: %v", err)
 	     }
 	     defer conn.Close()
 	     ctx := context.Background()
 	     // 建立gRPC连接
 	     grpcClient = pb.NewSimpleClient(conn)
 	     route(ctx, 2)
 	}
 	// route 调用服务端Route方法
 	func route(ctx context.Context, deadlines time.Duration) {
 	     //设置3秒超时时间
 	     clientDeadline := time.Now().Add(time.Duration(deadlines * time.Second))
 	     ctx, cancel := context.WithDeadline(ctx, clientDeadline)
 	     defer cancel()
 	     // 创建发送结构体
 	     req := pb.SimpleRequest{
 	         Data: "grpc",
 	     }
 	     // 调用我们的服务(Route方法)
 	     // 传入超时时间为3秒的ctx
 	     res, err := grpcClient.Route(ctx, & req)
 	     if err != nil {
 	         //获取错误状态
 	         statu, ok := status.FromError(err)
 	         if ok {
 	             //判断是否为调用超时
 	             if statu.Code() == codes.DeadlineExceeded {
 	                 log.Fatalln("Route timeout!")
 	             }
 	         }
 	         log.Fatalf("Call Route err: %v", err)
 	     }
 	     // 打印返回值
 	     log.Println(res.Value)
 	}

服务端判断请求是否超时

当请求超时后，服务端应该停止正在进行的操作，避免资源浪费。

 	// Route 实现Route方法
 	func (s *SimpleService) Route(ctx context.Context, req *pb.SimpleRequest) (*pb.SimpleResponse, error) {
 	     data := make(chan *pb.SimpleResponse, 1)
 	     go handle(ctx, req, data)
 	     select {
 	     case res := <-data:
 	         return res, nil
 	     case <-ctx.Done():
 	         return nil, status.Errorf(codes.Canceled, "Client cancelled, abandoning.")
 	     }
 	}
 	func handle(ctx context.Context, req *pb.SimpleRequest, data chan<- *pb.SimpleResponse) {
 	     select {
 	     case <-ctx.Done():
 	         log.Println(ctx.Err())
 	         runtime.Goexit() //超时后退出该Go协程
 	     case <-time.After(4 * time.Second): // 模拟耗时操作
 	         res := pb.SimpleResponse{
 	             Code: 200,
 	             Value: "hello " + req.Data,
 	         }
 	         // //修改 数据库前进行超时判断
 	         // if ctx.Err() == context.Canceled{
 	         // ...
 	         // //如果已经超时，则退出
 	         // }
 	         data <- & res
 	     }
 	}

一般地，在写库前进行超时检测，发现超时就停止工作。

完整server.go代码

 	package main
 	import (
 	     "context"
 	     "log"
 	     "net"
 	     "runtime"
 	     "time"
 	     "google.golang.org/grpc"
 	     "google.golang.org/grpc/codes"
 	     "google.golang.org/grpc/status"
 	     pb "go-grpc-example/6-grpc_deadlines/proto"
 	)
 	// SimpleService 定义我们的服务
 	type SimpleService struct{}
 	const (
 	     // Address 监听地址
 	     Address string = ":8000"
 	     // Network 网络通信协议
 	     Network string = "tcp"
 	)
 	func main() {
 	     // 监听本地端口
 	     listener, err := net.Listen(Network, Address)
 	     if err != nil {
 	         log.Fatalf("net.Listen err: %v", err)
 	     }
 	     log.Println(Address + " net.Listing...")
 	     // 新建gRPC服务器实例
 	     grpcServer := grpc.NewServer()
 	     // 在gRPC服务器注册我们的服务
 	     pb.RegisterSimpleServer(grpcServer, & SimpleService{})
 	     //用服务器 Serve() 方法以及我们的端口信息区实现阻塞等待，直到进程被杀死或者 Stop() 被调用
 	     err = grpcServer.Serve(listener)
 	     if err != nil {
 	         log.Fatalf("grpcServer.Serve err: %v", err)
 	     }
 	}
 	// Route 实现Route方法
 	func (s *SimpleService) Route(ctx context.Context, req *pb.SimpleRequest) (*pb.SimpleResponse, error) {
 	     data := make(chan *pb.SimpleResponse, 1)
 	     go handle(ctx, req, data)
 	     select {
 	     case res := <-data:
 	         return res, nil
 	     case <-ctx.Done():
 	         return nil, status.Errorf(codes.Canceled, "Client cancelled, abandoning.")
 	     }
 	}
 	func handle(ctx context.Context, req *pb.SimpleRequest, data chan<- *pb.SimpleResponse) {
 	     select {
 	     case <-ctx.Done():
 	         log.Println(ctx.Err())
 	         runtime.Goexit() //超时后退出该Go协程
 	     case <-time.After(4 * time.Second): // 模拟耗时操作
 	         res := pb.SimpleResponse{
 	             Code: 200,
 	             Value: "hello " + req.Data,
 	         }
 	         // //修改数据库前进行超时判断
 	         // if ctx.Err() == context.Canceled{
 	         // ...
 	         // //如果已经超时，则退出
 	         // }
 	         data <- & res
 	     }
 	}

运行结果

服务端：

:8000 net.Listing…
goroutine still running

客户端：

Route timeout!

总结

超时时间的长短需要根据自身服务而定，例如返回一个hello grpc，可能只需要几十毫秒，然而处理大量数据的同步操作则可能要很长时间。需要考虑多方面因素来决定这个超时时间，例如系统间端到端的延时，哪些RPC是串行的，哪些是可以并行的等等。

教程源码地址：https://github.com/Bingjian-Zhu/go-grpc-example

参考：https://grpc.io/blog/deadlines/