Go併發呼叫的超時處理

steak發表於2019-01-13
Go

之前有聊過 golang 的協程，我發覺似乎還很理論，特別是在併發安全上，所以特結合網上的一些例子，來試驗下go routine中 的 channel, select, context 的妙用。

場景-微服務呼叫

我們用 gin（一個web框架） 作為處理請求的工具，需求是這樣的：一個請求 X 會去並行呼叫 A, B, C 三個方法，並把三個方法返回的結果加起來作為 X 請求的 Response。但是我們這個 Response 是有時間要求的（不能超過5秒的響應時間），

可能 A, B, C 中任意一個或兩個，處理邏輯十分複雜，或者資料量超大，導致處理時間超出預期，那麼我們就馬上切斷，並返回已經拿到的任意個返回結果之和。

我們先來定義主函式：

func main() { 
r := gin.New() r.GET("/calculate", calHandler) http.ListenAndServe(":8008", r)
  }複製程式碼

非常簡單，普通的請求接受和 handler 定義。其中 calHandler 是我們用來處理請求的函式。

分別定義三個假的微服務，其中第三個將會是我們超時的哪位~

func microService1() int { 
time.Sleep(1*time.Second) return 1
  }func microService2() int { 
time.Sleep(2*time.Second) return 2
  }func microService3() int { 
time.Sleep(10*time.Second) return 3
  }複製程式碼

接下來，我們看看 calHandler 裡到底是什麼

func calHandler(c *gin.Context) { 
   ... c.JSON(http.StatusOK, gin.H{"code":200, "result": sum
  }) return
  }複製程式碼

一個典型的 gin Response，我們先不用在意 sum 是什麼。

要點1–併發呼叫

直接用 go 就好了嘛~所以一開始我們可能就這麼寫：

go microService1()go microService2()go microService3()複製程式碼

很簡單有沒有，但是等等，說好的返回值我怎麼接呢？為了能夠並行地接受處理結果，我們很容易想到用 channel 去接。所以我們把呼叫服務改成這樣：

var resChan = make(chan int, 3) // 因為有3個結果，所以我們建立一個可以容納3個值的 int channel。go func() { 
   resChan <
- microService1()
  }()go func() { 
   resChan <
- microService2()
  }()go func() { 
   resChan <
- microService3()
  }()複製程式碼

有東西接，那也要有方法去算，所以我們加一個一直迴圈拿 resChan 中結果並計算的方法：

var resContainer, sum intfor { 
   resContainer = <
-resChan    sum += resContainer
  }複製程式碼

這樣一來我們就有一個 sum 來計算每次從 resChan 中拿出的結果了。

要點2–超時訊號

還沒結束，說好的超時處理呢？為了實現超時處理，我們需要引入一個東西，就是 context，什麼是 context ?我們這裡只使用 context 的一個特性，超時通知（其實這個特性完全可以用 channel 來替代）。

可以看在定義 calHandler 的時候我們已經將 c *gin.Context 作為引數傳了進來，那我們就不用自己在宣告瞭。gin.Context 簡單理解為貫穿整個 gin 宣告週期的上下文容器，有點像是分身，亦或是量子糾纏的感覺。

有了這個 gin.Context， 我們就能在一個地方對 context 做出操作，而其他正在使用 context 的函式或方法，也會感受到 context 做出的變化。

ctx, _ := context.WithTimeout(c, 3*time.Second) //定義一個超時的 context複製程式碼

只要時間到了，我們就能用 ctx.Done() 獲取到一個超時的 channel(通知)，然後其他用到這個 ctx 的地方也會停掉，並釋放 ctx。一般來說，ctx.Done() 是結合 select 使用的。所以我們又需要一個迴圈來監聽 ctx.Done()

for { 
   select { 
   case <
- ctx.Done():        // 返回結果
  }複製程式碼

現在我們有兩個 for 了，是不是能夠合併下？

for { 
   select { 
   case resContainer = <
-resChan:        sum += resContainer        fmt.Println("add", resContainer)    case <
- ctx.Done():        fmt.Println("result:", sum)        return    
  }
  }複製程式碼

誒嘿，看上去不錯。不過我們怎麼在正常完成微服務呼叫的時候輸出結果呢？看來我們還需要一個 flag

var count intfor { 
   select { 
   case resContainer = <
-resChan:        sum += resContainer        count ++        fmt.Println("add", resContainer)        if count >
 2 { 
           fmt.Println("result:", sum)            return        
  }    case <
- ctx.Done():        fmt.Println("timeout result:", sum)        return    
  }
  }複製程式碼

我們加入一個計數器，因為我們只是呼叫3次微服務，所以當 count 大於2的時候，我們就應該結束並輸出結果了。

要點3–併發中的等待

上面的計時器是一種偷懶的方法，因為我們知道了呼叫微服務的次數，如果我們並不知道，或者之後還要新增呢？手動每次改 count 的判斷閾值會不會太不優雅了？這時候我們就可以加入 sync 包。我們將會使用的 sync 的一個特性是 WaitGroup。它的作用是等待一組協程執行完畢後，執行接下去的步驟。

我們來改下之前微服務呼叫的程式碼塊：

var success = make(chan int, 1) // 成功的通道標識wg := sync.WaitGroup{
  } // 建立一個 waitGroup 組wg.Add(3) // 我們往組裡加3個標識，因為我們要執行3個任務go func() { 
   resChan <
- microService1()    wg.Done() // 完成一個，Done()一個
  }()go func() { 
   resChan <
- microService2()    wg.Done()
  }()go func() { 
   resChan <
- microService3()    wg.Done()
  }()wg.Wait() // 直到我們前面三個標識都被 Done 了，否則程式一直會阻塞在這裡success <
- 1 // 我們傳送一個成功訊號到通道中複製程式碼

注意：如果我們直接把上面的程式碼放到 calHandler 裡，會出現一個問題，WaitGroup不論怎麼樣都會堵塞我們的正常情況輸出（死活都要讓你超時）。所以，我們把上面這段和業務邏輯相關的程式碼單獨抽離出來，幷包裝一下。

// rc 是結果 channel, success 是成功與否的 flag channelfunc MyLogic(rc chan<
- int, success chan<
- int) { 
wg := sync.WaitGroup{
  } // 建立一個 waitGroup 組 wg.Add(3) // 我們往組裡加3個標識，因為我們要執行3個任務 go func() { 
 rc <
- microService1()  wg.Done() // 完成一個，Done()一個 
  }() go func() { 
 rc <
- microService2()  wg.Done() 
  }() go func() { 
 rc <
- microService3()  wg.Done() 
  }() wg.Wait() // 直到我們前面三個標識都被 Done 了，否則程式一直會阻塞在這裡 success <
- 1 // 我們傳送一個成功訊號到通道中
  }複製程式碼

最終，這個 MyLogic 還是要作為一個協程執行的。(多謝@TomorrowWu和@chenqinghe提醒)

既然我們有了 success 這個訊號，那麼再把它加入到監控 for 迴圈中，並做些修改，刪除原來 count 判斷的部分。

for { 
select { 
case resContainer = <
-resChan:  sum += resContainer  fmt.Println("add", resContainer) case <
- success:  fmt.Println("result:", sum)  return case <
- ctx.Done():  fmt.Println("result:", sum)  return 
  }
  }複製程式碼

三個 case，分工明確，

case resContainer = <
-resChan:用來拿邏輯的輸出的結果並計算

case <
- success:是理想情況下的正常輸出

case <
- ctx.Done():是超時情況下的輸出

我們再潤色一下，把後兩個 case 的 fmt.Println("result:", sum)改為 gin 的標準 http Response

c.JSON(http.StatusOK, gin.H{"code":200, "result": sum
  })return複製程式碼

至此，所有的主要程式碼都完成了。下面是完全版

package mainimport ( "context" "fmt" "net/http" "sync" "time" "github.com/gin-gonic/gin")// 一個請求會觸發呼叫三個服務，每個服務輸出一個 int,// 請求要求結果為三個服務輸出 int 之和// 請求返回時間不超過3秒，大於3秒只輸出已經獲得的 int 之和func calHandler(c *gin.Context) { 
var resContainer, sum int var success, resChan = make(chan int), make(chan int, 3) ctx, cancel := context.WithTimeout(c, 5*time.Second) defer cancel() // 真正的業務邏輯 go MyLogic(resChan, success) for { 
 select { 
 case resContainer = <
-resChan:   sum += resContainer   fmt.Println("add", resContainer)  case <
- success:   c.JSON(http.StatusOK, gin.H{"code":200, "result": sum
  })   return  case <
- ctx.Done():   c.JSON(http.StatusOK, gin.H{"code":200, "result": sum
  })   return  
  } 
  }
  }func main() { 
r := gin.New() r.GET("/calculate", calHandler) http.ListenAndServe(":8008", r)
  }func MyLogic(rc chan<
- int, success chan<
- int) { 
wg := sync.WaitGroup{
  } // 建立一個 waitGroup 組 wg.Add(3) // 我們往組裡加3個標識，因為我們要執行3個任務 go func() { 
 rc <
- microService1()  wg.Done() // 完成一個，Done()一個 
  }() go func() { 
 rc <
- microService2()  wg.Done() 
  }() go func() { 
 rc <
- microService3()  wg.Done() 
  }() wg.Wait() // 直到我們前面三個標識都被 Done 了，否則程式一直會阻塞在這裡 success <
- 1 // 我們傳送一個成功訊號到通道中
  }func microService1() int { 
time.Sleep(1*time.Second) return 1
  }func microService2() int { 
time.Sleep(2*time.Second) return 2
  }func microService3() int { 
time.Sleep(6*time.Second) return 3
  }複製程式碼

上面的程式只是簡單描述了一個呼叫其他微服務超時的處理場景。實際過程中還需要加很多很多調料，才能保證介面的對外完整性。

來源：https://juejin.im/post/5c3aeffde51d4551140d96cf

相關文章