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

一、Goroutinue

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

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

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

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

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

二、WaitGroup

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

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

• Add()：給計數(shù)器添加等待 goroutine 的數(shù)量。
• Done()：減少 WaitGroup 計數(shù)器的值，應在協(xié)程的最后執(zhí)行。
• Wait()：執(zhí)行阻塞，直到所有的 WaitGroup 數(shù)量變成 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函數(shù)也可以寫成如下方式
func main() {
    var wg sync.WaitGroup
    wg.Add(3) //設置計數(shù)器，數(shù)值即為goroutine的個數(shù)
    go process(1, wg)
    go process(2, wg)
    go process(3, wg)
    wg.Wait() //主goroutine阻塞等待計數(shù)器變?yōu)?
    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 內部維護了一個計數(shù)器，激活了 3 個 goroutine：
1）每次激活 goroutine 之前，都先調用 Add() 方法增加一個需要等待的 goroutine 計數(shù)。
2）每個 goroutine 都運行 process() 函數(shù)，這個函數(shù)在執(zhí)行完成時需要調用 Done() 方法來表示 goroutine 的結束。
3）激活 3 個 goroutine 后，main 的 goroutine 會執(zhí)行到 Wait()，由于每個激活的 goroutine 運行的 process() 都需要睡眠 2 秒，所以 main 的 goroutine 在 Wait() 這里會阻塞一段時間(大約2秒)，
4）當所有 goroutine 都完成后，計數(shù)器減為 0，Wait() 將不再阻塞，于是 main 的 goroutine 得以執(zhí)行后面的 Println()。

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

fatal error: all goroutines are asleep - deadlock!

三、鎖

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

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

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

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