「连载九」gRPC Deadlines

前言

在前面的章节中，已经介绍了 gRPC 的基本用法。那你想想，让它这么裸跑真的没问题吗？

那么，肯定是有问题了。今天将介绍 gRPC Deadlines 的用法，这一个必备技巧。内容也比较简单

Deadlines

Deadlines 意指截止时间，在 gRPC 中强调 TL;DR（Too long, Don’t read）并建议始终设定截止日期，为什么呢？

为什么要设置

当未设置 Deadlines 时，将采用默认的 DEADLINE_EXCEEDED（这个时间非常大）

如果产生了阻塞等待，就会造成大量正在进行的请求都会被保留，并且所有请求都有可能达到最大超时

这会使服务面临资源耗尽的风险，例如内存，这会增加服务的延迟，或者在最坏的情况下可能导致整个进程崩溃

gRPC

Client

  1. func main() {
  2.     ...
  3.     ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Duration(5 * time.Second)))
  4.     defer cancel()
  6.     client := pb.NewSearchServiceClient(conn)
  7.     resp, err := client.Search(ctx, &pb.SearchRequest{
  8.         Request: "gRPC",
  9.     })
  10.     if err != nil {
  11.         statusErr, ok := status.FromError(err)
  12.         if ok {
  13.             if statusErr.Code() == codes.DeadlineExceeded {
  14.                 log.Fatalln("client.Search err: deadline")
  15.             }
  16.         }
  18.         log.Fatalf("client.Search err: %v", err)
  19.     }
  21.     log.Printf("resp: %s", resp.GetResponse())
  22. }
  • context.WithDeadline：会返回最终上下文截止时间。第一个形参为父上下文，第二个形参为调整的截止时间。若父级时间早于子级时间，则以父级时间为准，否则以子级时间为最终截止时间
  1. func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
  2.     if cur, ok := parent.Deadline(); ok && cur.Before(d) {
  3.         // The current deadline is already sooner than the new one.
  4.         return WithCancel(parent)
  5.     }
  6.     c := &timerCtx{
  7.         cancelCtx: newCancelCtx(parent),
  8.         deadline:  d,
  9.     }
  10.     propagateCancel(parent, c)
  11.     dur := time.Until(d)
  12.     if dur <= 0 {
  13.         c.cancel(true, DeadlineExceeded) // deadline has already passed
  14.         return c, func() { c.cancel(true, Canceled) }
  15.     }
  16.     c.mu.Lock()
  17.     defer c.mu.Unlock()
  18.     if c.err == nil {
  19.         c.timer = time.AfterFunc(dur, func() {
  20.             c.cancel(true, DeadlineExceeded)
  21.         })
  22.     }
  23.     return c, func() { c.cancel(true, Canceled) }
  24. }
  • context.WithTimeout：很常见的另外一个方法，是便捷操作。实际上是对于 WithDeadline 的封装
  1. func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
  2.     return WithDeadline(parent, time.Now().Add(timeout))
  3. }
  • status.FromError：返回 GRPCStatus 的具体错误码，若为非法，则直接返回 codes.Unknown

Server

  1. type SearchService struct{}
  3. func (s *SearchService) Search(ctx context.Context, r *pb.SearchRequest) (*pb.SearchResponse, error) {
  4.     for i := 0; i < 5; i++  {
  5.         if ctx.Err() == context.Canceled {
  6.             return nil, status.Errorf(codes.Canceled, "SearchService.Search canceled")
  7.         }
  9.         time.Sleep(1 * time.Second)
  10.     }
  12.     return &pb.SearchResponse{Response: r.GetRequest() + " Server"}, nil
  13. }
  15. func main() {
  16.     ...
  17. }

而在 Server 端，由于 Client 已经设置了截止时间。Server 势必要去检测它

否则如果 Client 已经结束掉了，Server 还傻傻的在那执行，这对资源是一种极大的浪费

因此在这里需要用 ctx.Err() == context.Canceled 进行判断，为了模拟场景我们加了循环和睡眠 🤔

验证

重新启动 server.go 和 client.go，得到结果：

  1. $ go run client.go
  2. 2018/10/06 17:45:55 client.Search err: deadline
  3. exit status 1

总结

本章节比较简单，你需要知道以下知识点：

  • 怎么设置 Deadlines
  • 为什么要设置 Deadlines

你要清楚地明白到，gRPC Deadlines 是很重要的，否则这小小的功能点就会要了你生产的命 🤫

参考

本系列示例代码

资料

「连载九」gRPC Deadlines - 图1