Go并發編程中sync/errGroup怎么使用

本篇內容介紹了“Go并發編程中sync/errGroup怎么使用”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

一.序

這一篇算是并發編程的一個補充，起因是當前有個項目，大概の 需求是，根據kafka的分區（partition）數，創建同等數量的 消費者（ goroutine）從不同的分區中消費者消費數據，但是總有某種原因導致，某一個分區消費者創建失敗，但是其他分區消費者創建失敗。 最初的邏輯是，忽略分區失敗的邏輯，將成功創建的分區消費者收集，用于獲取消息進行數據處理。 代碼就不在這里展示。

問題其實很明確： 如果在初始化分區消費者時，只要有一個消費創建失敗，那么初始化工作就算失敗，程序應該panic，退出。

但是當初設計時，消費者負責從kafka上游的某個topic獲取到數據，然后經過數據處理后，再通過生產者將處理后的數據發送到下游的topic中，由于當時設計時，代碼耦合比較重，導致無法通過初始化工作做這些，只能在啟動生產者后， 再創建消費者，這就導致 創建消費者-->獲取數據-->處理數據 雜糅到了一起。 這個問題一直到最近才有時間想著來解決。

比如有三個分區創建了三個分區的消費者，每個分區的消費者對應從自己的分區重獲取數據，三個分區最初使用waitGroup進行控制三個分區創建，只有當三個分區都創建完成后才會執行后續邏輯。 但是 waitgroup并不能很好的解決：只要一個 goroutine 出錯我們就不再等其他 goroutine 了，就默認創建分區消費者失敗了，所以此時便想到了 errGroup

二.errGroup

errGroup 是google開源的基礎擴展庫。使用時先進行下載

go get -u golang.org/x/sync

2.1 函數簽名

type Group struct {
 // contains filtered or unexported fields
}
 
    func WithContext(ctx context.Context) (*Group, context.Context)
    func (g *Group) Go(f func() error)
    func (g *Group) Wait() error

整個包就一個 Group 結構體

• 通過WaitContext 可以創建一個帶取消的group

• Go 方法傳入一個 func() error 內部會啟動一個goroutine 去處理

• Wait 類似WaitGroup的Wait 方法，等待所有的 goroutine結束后退出，返回的錯誤是一個出錯的 err

三.源碼

3.1 Group

type Group struct {
    // context 的 cancel 方法
 cancel func()
 
    // 復用 WaitGroup
 wg sync.WaitGroup
 
 // 用來保證只會接受一次錯誤
 errOnce sync.Once
    // 保存第一個返回的錯誤
 err     error
}

3.2 WaitContext

func WithContext(ctx context.Context) (*Group, context.Context) {
 ctx, cancel := context.WithCancel(ctx)
 return &Group{cancel: cancel}, ctx
}

WithContext 就是使用 WithCancel 創建一個可以取消的 context 將 cancel 賦值給 Group 保存起來，然后再將 context 返回回去

注意這里有一個坑，在后面的代碼中不要把這個 ctx 當做父 context 又傳給下游，因為 errgroup 取消了，這個 context 就沒用了，會導致下游復用的時候出錯

3.3 Go

func (g *Group) Go(f func() error) {
 g.wg.Add(1)
 
 go func() {
  defer g.wg.Done()
        
        // 通過執行傳入的匿名函數返回的錯誤值判斷是否需要執行cancel
  if err := f(); err != nil {
      // 這一點很重要，確保錯誤只會被執行一次
   g.errOnce.Do(func() {
    g.err = err
    if g.cancel != nil {
     g.cancel()
    }
   })
  }
 }()
}

Go 方法是一個封裝，相當于go 關鍵字的加強，會啟動一個攜程，然后利用waitgroup 來控制是否結束，如果有一個非 nil 的 error 出現就會保存起來并且如果有 cancel 就會調用 cancel 取消掉，使 ctx 返回

3.4 Wait

func (g *Group) Wait() error {
 g.wg.Wait()
 if g.cancel != nil {
  g.cancel()
 }
 return g.err
}

Wait 方法其實就是調用 WaitGroup 等待，如果有 cancel 就調用一下

四. 案例

基于 errgroup 實現一個 http server 的啟動和關閉 ，以及 linux signal 信號的注冊和處理，要保證能夠 一個退出，全部注銷退出。

package main
 
import (
 "context"
 "fmt"
 "log"
 "net/http"
 "os"
 "os/signal"
 "syscall"
 "time"
 
 "golang.org/x/sync/errgroup"
)
 
func main() {
 g, ctx := errgroup.WithContext(context.Background())
 
 mux := http.NewServeMux()
 mux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
  _, _ = w.Write([]byte("pong"))
 })
 
 // 模擬單個服務錯誤退出
 serverOut := make(chan struct{})
 mux.HandleFunc("/shutdown", func(w http.ResponseWriter, r *http.Request) {
  serverOut <- struct{}{}
 })
 
 server := http.Server{
  Handler: mux,
  Addr:    ":8099",
 }
 
 // g1
 // g1 退出了所有的協程都能退出么？
 // g1 退出后, context 將不再阻塞，g2, g3 都會隨之退出
 // 然后 main 函數中的 g.Wait() 退出，所有協程都會退出
 g.Go(func() error {
  err := server.ListenAndServe() // 服務啟動后會阻塞, 雖然使用的是 go 啟動，但是由于 g.WaitGroup 試得其是個阻塞的 協程
  if err != nil {
   log.Println("g1 error,will exit.", err.Error())
  }
  return err
 })
 
 // g2
 // g2 退出了所有的協程都能退出么？
 // 到調用 `/shutdown`接口時, serverOut 無緩沖管道寫入數據， case接收到數據后執行server.shutdown, 此時 g1 httpServer會退出
 // g1退出后，會返回error,將error加到g中，同時會調用 cancel()
 // g3 中會 select case ctx.Done, context 將不再阻塞，g3 會隨之退出
 // 然后 main 函數中的 g.Wait() 退出，所有協程都會退出
 g.Go(func() error {
  select {
  case <-ctx.Done():
   log.Println("g2 errgroup exit...")
  case <-serverOut:
   log.Println("g2, request `/shutdown`, server will out...")
  }
 
  timeoutCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
  // 這里不是必須的，但是如果使用 _ 的話靜態掃描工具會報錯，加上也無傷大雅
  defer cancel()
 
  err := server.Shutdown(timeoutCtx)
  log.Println("shutting down server...")
  return err
 })
 
 // g3
 // g3 捕獲到 os 退出信號將會退出
 // g3 退出了所有的協程都能退出么？
 // g3 退出后, context 將不再阻塞，g2 會隨之退出
 // g2 退出時，調用了 shutdown，g1 會退出
 // 然后 main 函數中的 g.Wait() 退出，所有協程都會退出
 g.Go(func() error {
  quit := make(chan os.Signal, 0)
  signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 
  select {
  case <-ctx.Done():
   log.Println("g3, ctx execute cancel...")
   log.Println("g3 error,", ctx.Err().Error())
   // 當g2退出時，已經有錯誤了，此時的error 并不會覆蓋到g中
   return ctx.Err()
  case sig := <-quit:
   return fmt.Errorf("g3 get os signal: %v", sig)
  }
 })
 
 // g.Wait 等待所有 go執行完畢后執行
 fmt.Printf("end, errgroup exiting, %+v\n", g.Wait())
}

運行測試

D:\gopath\src\Go_base\daily_test\errorGroup>go run demo.go

瀏覽器輸入http://127.0.0.1:8099/shutdown

控制臺輸出

2021/12/11 10:52:03 g2, request `/shutdown`, server will out...
2021/12/11 10:52:03 g1 error,will exit. http: Server closed
2021/12/11 10:52:03 g3, ctx execute cancel...
2021/12/11 10:52:03 g3 error, context canceled // 間隔了3s
2021/12/11 10:52:06 shutting down server...
end, errgroup exiting, http: Server closed

從執行結果可以看出，這種退出可以保證每個goroutine都能在完成正在執行的工作后退出

在terminal 按ctrl + c

輸出
2021/12/11 10:55:51 g2 errgroup exit...
2021/12/11 10:55:51 g1 error,will exit. http: Server closed
2021/12/11 10:55:51 shutting down server...
end, errgroup exiting, g3 get os signal: interrupt

“Go并發編程中sync/errGroup怎么使用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！