學 Go 的時候知道 Go 語言支持并發，最簡單的方法是通過 go 關鍵字開啟 goroutine 即可。可在工作中，用的是 sync 包的 WaitGroup，然而這樣還不夠，當多個 goroutine 同時訪問一個變量時，還要考慮如何保證這些 goroutine 之間不會相互影響，這就又使用到了 sync 的 Mutex。它們是如何串起來的呢？

一、Goroutinue

先說 goroutine，我們都知道它是 Go 中的輕量級線程。Go 程序從 main 包的 main() 函數開始，在程序啟動時，Go 程序就會為 main() 函數創建一個默認的 goroutine。使用 goroutine，使用關鍵字 go 即可。

package main
import (
    "fmt"
)
func main() {
    // 并發執行程序
    go running()
}
func running() {
    fmt.Println("Goroutine")
}

執行代碼會發現沒有我們預期的“Goroutine”輸出，這是因為當前的程序是一個單線程的程序，main 函數只要執行后，就不會再管其他線程在做什么事情，程序就自動退出了。解決辦法是加一個 sleep 函數，讓 main 函數等待 running 函數執行完畢后再退出。我們假設 running 函數里的代碼執行需要 2 秒，因此讓 main 函數等待 3 秒再退出。

package main
import (
    "fmt"
    "time"
)
func main() {
    // 并發執行程序
    go running()
    time.Sleep(3 * time.Second)
}
func running() {
    fmt.Println("Goroutine")
}

再次執行代碼，終端輸出了我們想要的“Goroutine”字符串。

二、WaitGroup

上面我們是假設了 running 函數執行需要 2 秒，可如果執行需要 10 秒甚至更長時間，不知道 goroutin 什么時候結束，難道還要 main 函數 sleep 更多的秒數嗎？就不能讓 running 函數執行完去通知 main 函數，main 函數收到信號自動退出嗎？還真可以！可以使用 sync 包的 Waitgroup 判斷一組任務是否完成。

WatiGroup 能夠一直等到所有的 goroutine 執行完成，并且阻塞主線程的執行，直到所有的 goroutine 執行完成。它有 3 個方法：

• Add()：給計數器添加等待 goroutine 的數量。
• Done()：減少 WaitGroup 計數器的值，應在協程的最后執行。
• Wait()：執行阻塞，直到所有的 WaitGroup 數量變成 0

一個簡單的示例如下：

package main 
import ( 
    "fmt” 
    "sync” 
    “time"
) 

func process(i int, wg *sync.WaitGroup) { 
    fmt.Println("started Goroutine ", i) 
    time.Sleep(2 * time.Second) 
    fmt.Printf("Goroutine %d ended\n", i) 
    wg.Done() 
} 

func main() { 
    var wg sync.WaitGroup 
    for i := 0; i  3; i++ { 
        wg.Add(1) 
        go process(i, wg) 
    } 
    wg.Wait() 
    fmt.Println("All go routines finished executing”) 
}
//main函數也可以寫成如下方式
func main() {
    var wg sync.WaitGroup
    wg.Add(3) //設置計數器，數值即為goroutine的個數
    go process(1, wg)
    go process(2, wg)
    go process(3, wg)
    wg.Wait() //主goroutine阻塞等待計數器變為0
    fmt.Println("All goroutines finished executing")
}

命令行輸出如下：

deer@192 src % go run hello.go //第1次
started Goroutine  3
started Goroutine  1
started Goroutine  2
Goroutine 2 ended
Goroutine 1 ended
Goroutine 3 ended
All goroutines finished executing

deer@192 src % go run hello.go //第2次
started Goroutine  3
started Goroutine  1
started Goroutine  2
Goroutine 1 ended
Goroutine 2 ended
Goroutine 3 ended
All goroutines finished executing

deer@192 src % go run hello.go //第3次
started Goroutine  3
started Goroutine  2
started Goroutine  1
Goroutine 3 ended
Goroutine 1 ended
Goroutine 2 ended
All goroutines finished executing

簡單的說，上面程序中 wg 內部維護了一個計數器，激活了 3 個 goroutine：
1）每次激活 goroutine 之前，都先調用 Add() 方法增加一個需要等待的 goroutine 計數。
2）每個 goroutine 都運行 process() 函數，這個函數在執行完成時需要調用 Done() 方法來表示 goroutine 的結束。
3）激活 3 個 goroutine 后，main 的 goroutine 會執行到 Wait()，由于每個激活的 goroutine 運行的 process() 都需要睡眠 2 秒，所以 main 的 goroutine 在 Wait() 這里會阻塞一段時間(大約2秒)，
4）當所有 goroutine 都完成后，計數器減為 0，Wait() 將不再阻塞，于是 main 的 goroutine 得以執行后面的 Println()。

這里需要注意：
1）process() 中使用指針類型的 *sync.WaitGroup 作為參數，表示這 3 個 goroutine 共享一個 wg，才能知道這 3 個 goroutine 都完成了。如果這里使用值類型的 sync.WaitGroup 作為參數，意味著每個 goroutine 都拷貝一份 wg，每個 goroutine 都使用自己的 wg，main goroutine將會永久阻塞而導致產生死鎖。
2）Add() 設置的數量必須與實際等待的 goroutine 個數一致，也就是和Done的調用數量必須相等，否則會panic，報錯信息如下：

fatal error: all goroutines are asleep - deadlock!

三、鎖

當多個 goroutine 同時操作一個變量時，會存在數據競爭，導致最后的結果與期待的不符，解決辦法就是加鎖。Go 中的 sync 包 實現了兩種鎖：Mutex 和 RWMutex，前者為互斥鎖，后者為讀寫鎖，基于 Mutex 實現。當我們的場景是寫操作為主時，可以使用 Mutex 來加鎖、解鎖。

var lock sync.Mutex //聲明一個互斥鎖
 lock.Lock() //加鎖
//code...
 lock.Unlock() //解鎖

互斥鎖其實就是每個線程在對資源操作前都嘗試先加鎖，成功加鎖才能操作，操作結束后再解鎖。也就是說，使用了互斥鎖，同一時刻只能有一個 goroutine 在執行。

以上就是解析Go的Waitgroup和鎖的問題的詳細內容，更多關于Go的Waitgroup和鎖的資料請關注腳本之家其它相關文章！