為什么需要超時(shí)控制？

• 請求時(shí)間過長，用戶側(cè)可能已經(jīng)離開本頁面了，服務(wù)端還在消耗資源處理，得到的結(jié)果沒有意義
• 過長時(shí)間的服務(wù)端處理會(huì)占用過多資源，導(dǎo)致并發(fā)能力下降，甚至出現(xiàn)不可用事故

Go 超時(shí)控制必要性

Go 正常都是用來寫后端服務(wù)的，一般一個(gè)請求是由多個(gè)串行或并行的子任務(wù)來完成的，每個(gè)子任務(wù)可能是另外的內(nèi)部請求，那么當(dāng)這個(gè)請求超時(shí)的時(shí)候，我們就需要快速返回，釋放占用的資源，比如goroutine，文件描述符等。

服務(wù)端常見的超時(shí)控制

• 進(jìn)程內(nèi)的邏輯處理
• 讀寫客戶端請求，比如HTTP或者RPC請求
• 調(diào)用其它服務(wù)端請求，包括調(diào)用RPC或者訪問DB等

沒有超時(shí)控制會(huì)怎樣？

為了簡化本文，我們以一個(gè)請求函數(shù) hardWork 為例，用來做啥的不重要，顧名思義，可能處理起來比較慢。

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

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

這時(shí)客戶端看到的就一直是大家熟悉的畫面

<img src="https://gitee.com/kevwan/static/raw/master/doc/images/loading.jpg" width="25%">

絕大部分用戶都不會(huì)看一分鐘菊花，早早棄你而去，空留了整個(gè)調(diào)用鏈路上一堆資源的占用，本文不究其它細(xì)節(jié)，只聚焦超時(shí)實(shí)現(xiàn)。

下面我們看看該怎么來實(shí)現(xiàn)超時(shí)，其中會(huì)有哪些坑。

第一版實(shí)現(xiàn)

大家可以先不往下看，自己試著想想該怎么實(shí)現(xiàn)這個(gè)函數(shù)的超時(shí)，第一次嘗試：

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()
  }
}

我們寫個(gè) main 函數(shù)測試一下

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

超時(shí)已經(jīng)生效。但這樣就搞定了嗎？

goroutine 泄露

讓我們在main函數(shù)末尾加一行代碼看看執(zhí)行完有多少goroutine

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

sleep 2分鐘是為了等待所有任務(wù)結(jié)束，然后我們打印一下當(dāng)前goroutine數(shù)量。讓我們執(zhí)行一下看看結(jié)果

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

goroutine泄露了，讓我們看看為啥會(huì)這樣呢？首先，requestWork 函數(shù)在2秒鐘超時(shí)后就退出了，一旦 requestWork 函數(shù)退出，那么 done channel 就沒有g(shù)oroutine接收了，等到執(zhí)行 done <- hardWork(job) 這行代碼的時(shí)候就會(huì)一直卡著寫不進(jìn)去，導(dǎo)致每個(gè)超時(shí)的請求都會(huì)一直占用掉一個(gè)goroutine，這是一個(gè)很大的bug，等到資源耗盡的時(shí)候整個(gè)服務(wù)就失去響應(yīng)了。

那么怎么fix呢？其實(shí)也很簡單，只要 make chan 的時(shí)候把 buffer size 設(shè)為1，如下：

done := make(chan error, 1)

這樣就可以讓 done <- hardWork(job) 不管在是否超時(shí)都能寫入而不卡住goroutine。此時(shí)可能有人會(huì)問如果這時(shí)寫入一個(gè)已經(jīng)沒goroutine接收的channel會(huì)不會(huì)有問題，在Go里面channel不像我們常見的文件描述符一樣，不是必須關(guān)閉的，只是個(gè)對象而已，close(channel) 只是用來告訴接收者沒有東西要寫了，沒有其它用途。

改完這一行代碼我們再測試一遍：

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

goroutine泄露問題解決了！

panic 無法捕獲

讓我們把 hardWork 函數(shù)實(shí)現(xiàn)改成

panic("oops")

修改 main 函數(shù)加上捕獲異常的代碼如下：

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

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

此時(shí)執(zhí)行一下就會(huì)發(fā)現(xiàn)panic是無法被捕獲的，原因是因?yàn)樵?requestWork 內(nèi)部起的goroutine里產(chǎn)生的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 的調(diào)用方處理 panic 了。

超時(shí)時(shí)長一定對嗎？

上面的 requestWork 實(shí)現(xiàn)忽略了傳入的 ctx 參數(shù)，如果 ctx 已有超時(shí)設(shè)置，我們一定要關(guān)注此傳入的超時(shí)是不是小于這里給的2秒，如果小于，就需要用傳入的超時(shí)，go-zero/core/contextx 已經(jīng)提供了方法幫我們一行代碼搞定，只需修改如下：

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

Data race

這里 requestWork 只是返回了一個(gè) error 參數(shù)，如果需要返回多個(gè)參數(shù)，那么我們就需要注意 data race，此時(shí)可以通過鎖來解決，具體實(shí)現(xiàn)參考 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())
}

更多細(xì)節(jié)

請參考 go-zero 源碼：

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

項(xiàng)目地址
https://github.com/tal-tech/go-zero

到此這篇關(guān)于一文搞懂如何實(shí)現(xiàn)Go 超時(shí)控制的文章就介紹到這了,更多相關(guān)Go 超時(shí)控制內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論