Go並發:使用sync.WaitGroup實現協程同步方式

Posted on by

經常看到有人會問如何等待主協程中創建的協程執行完畢之後再結束主協程，例如如下代碼：

package main
import (
    "fmt"
)
func main() {
    go func() {
        fmt.Println("Goroutine 1")
    }()
    go func() {
        fmt.Println("Goroutine 2")
    }()
}

執行以上代碼很可能看不到輸出，因為有可能這兩個協程還沒得到執行主協程已經結束瞭，而主協程結束時會結束所有其他協程。

解決辦法是可以在main函數結尾加上等待：

package main
import (
    "fmt"
    "time"
)
func main() {
    go func() {
        fmt.Println("Goroutine 1")
    }()
    go func() {
        fmt.Println("Goroutine 2")
    }()
    time.Sleep(time.Second * 1) // 睡眠1秒，等待上面兩個協程結束
}

這並不是完美的解決方法，如果這兩個協程中包含復雜的操作，可能很耗時間，就無法確定需要睡眠多久，當然可以用管道實現同步：

package main
import (
    "fmt"
)
func main() {
    ch := make(chan struct{})
    count := 2 // count 表示活動的協程個數
    go func() {
        fmt.Println("Goroutine 1")
        ch <- struct{}{} // 協程結束，發出信號
    }()
    go func() {
        fmt.Println("Goroutine 2")
        ch <- struct{}{} // 協程結束，發出信號
    }()
    for range ch {
        // 每次從ch中接收數據，表明一個活動的協程結束
        count--
        // 當所有活動的協程都結束時，關閉管道
        if count == 0 {
            close(ch)
        }
    }
}

上面的解決方案是比較完美的方案，但是Go提供瞭更簡單的方法——使用sync.WaitGroup。

WaitGroup顧名思義，就是用來等待一組操作完成的。

WaitGroup內部實現瞭一個計數器，用來記錄未完成的操作個數，它提供瞭三個方法，Add()用來添加計數。

Done()用來在操作結束時調用，使計數減一。

Wait()用來等待所有的操作結束，即計數變為0，該函數會在計數不為0時等待，在計數為0時立即返回。

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    wg.Add(2) // 因為有兩個動作，所以增加2個計數
    go func() {
        fmt.Println("Goroutine 1")
        wg.Done() // 操作完成，減少一個計數
    }()
    go func() {
        fmt.Println("Goroutine 2")
        wg.Done() // 操作完成，減少一個計數
    }()
    wg.Wait() // 等待，直到計數為0
}

可見用sync.WaitGroup是最簡單的方式。

補充：Golang 中使用WaitGroup的那點坑

sync.WaitGroup對於Golang開發者來說並不陌生，其經常作為多協程之間同步的一種機制。用好它勢必會讓你事半功倍，但是一旦錯用將引發問題。

關於WaitGroup的使用網上有很多例子，在此就不做介紹瞭，我想說的是我在項目中使用WaitGroup遇到的坑。

在項目中，因為服務器有同步需求， 所以直接使用瞭WaitGroup，但是未考慮使用場景，結果在項目上線之後，高峰期的時候客戶端經常出現卡頓，經過多方查找，才發現如果使用WaitGroup的時候，未啟動單獨的goroutine，那麼極有可能造成主線程的阻塞，

所以我做瞭下面的測試(測試中，我把WaitGroup置於協程內)：

import (
 "fmt"
 "sync"
 "time"
)
 
func main() {
    fmt.Println("main-1")
 testW()
 fmt.Println("main-2")
 time.Sleep(time.Duration(15) * time.Second) 
}
 
func testW() {
 fmt.Println("testW-1")
 go func() {
  var wg sync.WaitGroup
  fmt.Println("testW-2")
  testW1(&wg)
  fmt.Println("testW-5")
  wg.Wait()
  fmt.Println("testW-6")
 }()
}
 
func testW1(wg *sync.WaitGroup) {
 wg.Add(1)
 fmt.Println("testW-3")
 time.AfterFunc(time.Second*5, func() {
  wg.Done()
 })
 fmt.Println("testW-4") 
}

輸出為：

main-1

testchan-1

main-2

testchan-2

testchan-3

testchan-4

testchan-5

// 過5秒

testchan-6

總結：

將WaitGroup用於goroutine內，不會導致主線程的阻塞，同樣可以實現同步的效果。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：