十二. Go併發程式設計--sync/errGroup

failymao發表於2021-12-12
Go程式設計

一.序

這一篇算是併發程式設計的一個補充，起因是當前有個專案，大概の 需求是，根據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

  1. 瀏覽器輸入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都能在完成正在執行的工作後退出

  2. 在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

分析都在程式碼註釋中

五. 參考

  1. https://lailin.xyz/post/go-training-week3-errgroup.html
  2. https://pkg.go.dev/golang.org/x/sync/errgroup

相關文章