关于golang:一文搞懂如何实现-Go-超时控制

59次阅读

共计 4195 个字符，预计需要花费 11 分钟才能阅读完成。

申请工夫过长，用户侧可能曾经来到本页面了，服务端还在耗费资源解决，失去的后果没有意义
过长时间的服务端解决会占用过多资源，导致并发能力降落，甚至呈现不可用事变

Go 失常都是用来写后端服务的，个别一个申请是由多个串行或并行的子工作来实现的，每个子工作可能是另外的外部申请，那么当这个申请超时的时候，咱们就须要疾速返回，开释占用的资源，比方 goroutine，文件描述符等。

过程内的逻辑解决
读写客户端申请，比方 HTTP 或者 RPC 申请
调用其它服务端申请，包含调用 RPC 或者拜访 DB 等

为了简化本文，咱们以一个申请函数 hardWork 为例，用来做啥的不重要，顾名思义，可能解决起来比较慢。

func hardWork(job interface{}) error {time.Sleep(time.Minute)
    return nil
}

func requestWork(ctx context.Context, job interface{}) error {return hardWork(job)
}

这时客户端看到的就始终是大家相熟的画面

绝大部分用户都不会看一分钟菊花，早早弃你而去，空留了整个调用链路上一堆资源的占用，本文不究其它细节，只聚焦超时实现。

上面咱们看看该怎么来实现超时，其中会有哪些坑。

大家能够先不往下看，本人试着想想该怎么实现这个函数的超时，第一次尝试：

func requestWork(ctx context.Context, job interface{}) error {ctx, cancel := context.WithTimeout(ctx, time.Second*2)
    defer cancel()

    done := make(chan error)
    go func() {done <- hardWork(job)
    }()

    select {
    case err := <-done:
        return err
    case <-ctx.Done():
        return ctx.Err()}
}

咱们写个 main 函数测试一下

func main() {
    const total = 1000
    var wg sync.WaitGroup
    wg.Add(total)
    now := time.Now()
    for i := 0; i < total; i++ {go func() {defer wg.Done()
            requestWork(context.Background(), "any")
        }()}
    wg.Wait()
    fmt.Println("elapsed:", time.Since(now))
}

跑一下试试成果

➜ go run timeout.go
elapsed: 2.005725931s

超时曾经失效。但这样就搞定了吗？

让咱们在 main 函数开端加一行代码看看执行完有多少 goroutine

time.Sleep(time.Minute*2)
fmt.Println("number of goroutines:", runtime.NumGoroutine())

sleep 2 分钟是为了期待所有工作完结，而后咱们打印一下以后 goroutine 数量。让咱们执行一下看看后果

➜ go run timeout.go
elapsed: 2.005725931s
number of goroutines: 1001

goroutine 泄露了，让咱们看看为啥会这样呢？首先，requestWork 函数在 2 秒钟超时后就退出了，一旦 requestWork 函数退出，那么 done channel 就没有 goroutine 接管了，等到执行 done <- hardWork(job) 这行代码的时候就会始终卡着写不进去，导致每个超时的申请都会始终占用掉一个 goroutine，这是一个很大的 bug，等到资源耗尽的时候整个服务就失去响应了。

那么怎么 fix 呢？其实也很简略，只有 make chan 的时候把 buffer size 设为 1，如下：

done := make(chan error, 1)

这样就能够让 done <- hardWork(job) 不论在是否超时都能写入而不卡住 goroutine。此时可能有人会问如果这时写入一个曾经没 goroutine 接管的 channel 会不会有问题，在 Go 外面 channel 不像咱们常见的文件描述符一样，不是必须敞开的，只是个对象而已，close(channel) 只是用来通知接收者没有货色要写了，没有其它用处。

改完这一行代码咱们再测试一遍：

➜ go run timeout.go
elapsed: 2.005655146s
number of goroutines: 1

goroutine 泄露问题解决了！

让咱们把 hardWork 函数实现改成

panic("oops")

批改 main 函数加上捕捉异样的代码如下：

go func() {defer func() {if p := recover(); p != nil {fmt.Println("oops, panic")
    }
  }()

  defer wg.Done()
  requestWork(context.Background(), "any")
}()

此时执行一下就会发现 panic 是无奈被捕捉的，起因是因为在 requestWork 外部起的 goroutine 里产生的 panic 其它 goroutine 无奈捕捉。

解决办法是在 requestWork 里加上 panicChan 来解决，同样，须要 panicChan 的 buffer size 为 1，如下：

func requestWork(ctx context.Context, job interface{}) error {ctx, cancel := context.WithTimeout(ctx, time.Second*2)
    defer cancel()

    done := make(chan error, 1)
    panicChan := make(chan interface{}, 1)
    go func() {defer func() {if p := recover(); p != nil {panicChan <- p}
        }()

        done <- hardWork(job)
    }()

    select {
    case err := <-done:
        return err
    case p := <-panicChan:
        panic(p)
    case <-ctx.Done():
        return ctx.Err()}
}

改完就能够在 requestWork 的调用方解决 panic 了。

下面的 requestWork 实现疏忽了传入的 ctx 参数，如果 ctx 已有超时设置，咱们肯定要关注此传入的超时是不是小于这里给的 2 秒，如果小于，就须要用传入的超时，go-zero/core/contextx 曾经提供了办法帮咱们一行代码搞定，只需批改如下：

ctx, cancel := contextx.ShrinkDeadline(ctx, time.Second*2)

这里 requestWork 只是返回了一个 error 参数，如果须要返回多个参数，那么咱们就须要留神 data race，此时能够通过锁来解决，具体实现参考 go-zero/zrpc/internal/serverinterceptors/timeoutinterceptor.go，这里不做赘述。

package main

import (
    "context"
    "fmt"
    "runtime"
    "sync"
    "time"

    "github.com/tal-tech/go-zero/core/contextx"
)

func hardWork(job interface{}) error {time.Sleep(time.Second * 10)
    return nil
}

func requestWork(ctx context.Context, job interface{}) error {ctx, cancel := contextx.ShrinkDeadline(ctx, time.Second*2)
    defer cancel()

    done := make(chan error, 1)
    panicChan := make(chan interface{}, 1)
    go func() {defer func() {if p := recover(); p != nil {panicChan <- p}
        }()

        done <- hardWork(job)
    }()

    select {
    case err := <-done:
        return err
    case p := <-panicChan:
        panic(p)
    case <-ctx.Done():
        return ctx.Err()}
}

func main() {
    const total = 10
    var wg sync.WaitGroup
    wg.Add(total)
    now := time.Now()
    for i := 0; i < total; i++ {go func() {defer func() {if p := recover(); p != nil {fmt.Println("oops, panic")
                }
            }()

            defer wg.Done()
            requestWork(context.Background(), "any")
        }()}
    wg.Wait()
    fmt.Println("elapsed:", time.Since(now))
    time.Sleep(time.Second * 20)
    fmt.Println("number of goroutines:", runtime.NumGoroutine())
}

请参考 go-zero 源码：

go-zero/core/fx/timeout.go
go-zero/zrpc/internal/clientinterceptors/timeoutinterceptor.go
go-zero/zrpc/internal/serverinterceptors/timeoutinterceptor.go

https://github.com/tal-tech/go-zero

欢送应用 go-zero 并 star 反对咱们！

关注『微服务实际』公众号并回复进群获取社区群二维码。

go-zero 系列文章见『微服务实际』公众号

正文完

golang

发表至： golang

2021-03-29

0

关于golang:快速排序归并排序

关于golang:Go-开发环境通过-iTerm-Oh-My-Zsh-打造终端

关于golang:GO-中-map-的实现原理

关于golang:有趣的面试题Go语言中nil的比较结果

关于spring:java并发编程工具类JUC第七篇BlockingDeque双端阻塞队列

关于golang:一文搞懂如何实现-Go-超时控制

为什么须要超时管制？

Go 超时管制必要性

服务端常见的超时管制

没有超时管制会怎么？

第一版实现

goroutine 泄露

panic 无奈捕捉

超时时长肯定对吗？

Data race

残缺示例

更多细节

我的项目地址

微信交换

Just My Socks（注册教程内含优惠码）

关于golang:一文搞懂如何实现-Go-超时控制

为什么须要超时管制？

Go 超时管制必要性

服务端常见的超时管制

没有超时管制会怎么？

第一版实现

goroutine 泄露

panic 无奈捕捉

超时时长肯定对吗？

Data race

残缺示例

更多细节

我的项目地址

微信交换

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）