今天把 A Tour of Go 的最后章節看完，
1. goroutine（Go 程）
goroutine 是 Go 管理的一個輕量級執行緒，
go f(x, y, z)
goroutine 會先對 f,x,y,z 求值，再把 f(x, y, z) 放到一個新的 goroutine 中，
注意：如果主執行緒結束，所有的 goroutine 也會結束，所以不要把 goroutine 放在最后一行，你會發現 goroutine 就像不存在一樣根本不執行，
2. 信道 channels
goroutine 在同一個地址空間中運行，因此如果兩個 goroutine 要用到同一個記憶體的時候，就需要同步，sync 包也可以干這個，但沒必要，go 有自己的信道，
ch = make(chan int) // 注意 chan 是個關鍵字不是變數名，"chan int" 合起來是一個儲存 int 的信道型別
看語法大概也能直到，信道就是帶型別的管道，用法如下：
ch <- va // "<-" 作為符號
vb := <-ch // "<-" 與 "ch" 連在一起組成 "<-ch"，中間無空格，"<-ch" 是一個值
- 第一條陳述句是把 va 的值儲存在 ch 中，
- 第二條陳述句是從 ch 中把剛儲存的值取出來（"<-ch" 是個值，因為很重要所以說兩遍），然后賦值給 vb，
2.1 同步操作
信道之所能夠進行同步，是因為信道的特性，發送和接收（就是上面兩條陳述句）在另一端完成之前會被阻塞，比如說:
func sum(x, y, z int, ch chan int) {
sum := x + y + z
ch <- sum
}
func main() {
ch := make(chan int)
go sum(x1, y1, z1, ch)
go sum(x2, y2, z2, ch)
var x, y = <-ch, <-ch
// do sth with x, y
// ......
}
假設有這么兩個 goroutine 使用了同一個信道：
- 主代碼運行的時候，遇到第一個 goroutine，計算 x1, y1, z1, ch, sum 函式的值，掛起一個新的 goroutine 執行 sum，
- 遇到第二個 goroutine，計算 x2, y2, z2, ch, sum 函式的值，掛起一個新的 goroutine 執行 sum，
- 就在掛起第二個 goroutine 的時候，沒想到第一個 sum 快如神速，已經計算完了，執行到了 ch <- sum，但是很可惜，主執行緒甚至還沒執行到
var x, y = <-ch, <-ch這一行，ch 沒有在接收資料，于是第一個 sum 只好阻塞，等待， - 主執行緒終于創建好了第二個 goroutine，于是從 ch 里取值并復制到 x, y ，于是開始計算第一個 <-ch，發現這不是剛好有一個 goroutine 在等我接收嗎？我直接接收資料，我直接取值，我直接賦值給 x，
- 然后主執行緒到了第二個 <-ch，準備再次接收資料，然而很可惜，第二個 sum 慢如龜速，還在執行呢，沒辦法，主執行緒只好擱置，等待有 goroutine 往 ch 里發送資料，
- 終于第二個 sum 函式執行到了
ch <- sum這一行，有值被發送到了 ch，掛起的接受端立刻使用 <-ch 從 ch 中取值，賦值給 x， - 終于 x, y 都被賦值完成，可以進行下一步的操作了，
阻塞保證了發送資料和接收資料的同步，
2.2 緩沖信道
信道每次接收資料都阻塞，但有時候我們就是想連續傳多次資料，就是對完全同步沒有那么大的要求，不想等第一個接收完了再傳，而是可以一次接收多個資料，再傳給接受者，怎么辦呢？
- 這里就可以用到緩沖信道，在創建信道的時候宣告緩沖大小
make(chan int, 100)賦予 100 個 int 大小的緩沖記憶體，就是說可以儲存 100 個 int，
這樣下面的代碼就可以正常運行了：
var ch = make(chan int, 2)
ch <- 1
ch <- 2
x := <-ch
y := <-ch
fmt.Println(x, y)
如果不是緩沖信道的話，運行到 ch <- 2 這一步就完蛋了，因為 ch 在 ch <- 1 的時候就已經阻塞了，而接收在后面，因此會造成 DeadLock，
但是上面的代碼是可以運行的，因為有 buffer 可以存兩個 int，并且要在往里存第三個 int 的時候，才會阻塞，
所以其實非緩沖信道相當于 make(chan int , 0)（不是 make(chan int , 1) 哦， 1 的話是可以存一個資料的且只有在第二次存值的時候才會報錯，也就是說可以在同一個 goroutine 上先存一個值再使用，雖然這沒有意義（笑））
2.3 close 和 range
2.3.1 close 關閉發送端
顧名思義，close 就是關閉信道，實際上是關閉發送端，可以在接收的時候使用雙賦值來得到信道的關閉資訊，
ch = make(chan int, 1)
ch <- 1
v1, ok1 := <-ch
fmt.Println(v1, ok1) // "1, true"
close(ch)
v2, ok2 := <-ch
fmt.Println(v2, ok2) // "0, false"
為什么說關閉的是信號的發送端呢?因為如下代碼是可以運行的：
ch := make(chan int, 1)
ch <- 1
close(ch) // 在 close 之前，已經往 buffered ch 里存了一個 int
v1, ok1 := <-ch
fmt.Println(v1, ok1) // "1, true"，buffer 里有的，依然可以收到
v2, ok2 := <-ch
fmt.Println(v2, ok2) // "0, false"，即使 buffer 是空的，依然不會報錯，只是會得到零值
-
因為關閉的是發送端，所以只有發送者能夠關閉信道（規定，不是語法，但你違反這個規定一般也會報錯就是了），如果是接收者關閉信道了，發送者再發送一個資料到信道會觸發 panic，
-
但是發送者關閉信道后，接收者還是能不報錯的接收資料的
** （注意：發送端和接收端是相對于一個信道而言的，不是 goroutine 而言的，一個 goroutine 可以既有發送的信道，也有接收的信道） **
2.3.2 range 持續接收資料
對信道使用 range，會不斷從信道中接收資料，直到信道關閉，
func sendData(ch chan int) {
for i := 0; i < 10; i++ {
ch <- i
if i == 5 {
close(ch)
break
}
}
}
func main() {
ch := make(chan int, 10)
go sendData(ch)
for i := range ch {
fmt.Println(i)
}
fmt.Println("end")
}
// 輸出：
// 1
// 2
// 3
// 4
// 5
// end
2.4 select
注意不要和 switch 搞混，因為兩者長得很像，而且都用到 case 關鍵詞，語法結構也像，但是 select 是用于并發的，
- 有時候，我們會有多個信道等待另一方發送或接收資料，而我們想等其中任意一個信道準備好了就先吧那個信道的事情處理好，這時候就需要 select 陳述句來幫忙了，
- 和 switch 一樣，select 也有 default 陳述句，會在所有信道都沒準備好的時候運行，如果不想干巴巴的什么都不輸出就在那堵塞的時候可以用，
select 的一個常見用法是在回圈中使用：
for {
select {
case <-ch1:
// do sth with ch1
case <-ch2:
// do sth with ch2
default:
// do sth
// i.e. fmt.Println("waiting...")
// time.Sleep(100 * time.Millisecond)
}
}
由于有 default，select 永遠都不會堵塞，在其他 case 沒有準備好的時候，會一直呼叫 default，通過 defualt 里的 time.sleep 控制呼叫頻率，
3. sync.Mutex
如果看完以上，你應該直到信道的作用是在各個行程之間通信，但是如果我們并沒有想通信，而只是想有一個共享變數，并限制 goroutine 一次只能有一個 goroutine 能訪問這個變數，
這個概念叫做 mutual exclusion，簡稱 Mutex（互斥鎖），
正好我們有一個包 sync 包，提供了 sync.Mutex 型別，該型別有兩個方法：Lock() 和 Unlock() ，
這兩個方法的用法顧名思義，在一段代碼前呼叫 Lock() 方法，在代碼運行完畢后呼叫 Unlock() 方法，就可以保證同時只能有一個 goroutine 在訪問這段代碼，可以使用 defer 關鍵字把 Unlock() 的呼叫放在整段函式呼叫完畢時，
如果看文字沒法理解的話，請參閱這里，
4. sync.WaitGroup
經常遇到這樣的情況：你遞回地運行一個函式，每次呼叫都是一個 goroutine，然后這個呼叫是主執行緒的最后一行，于是你發現代碼根本不跑，因為主執行緒一結束就沒了，為了解決這個辦法：
- 你可以用 time.Sleep，但是不優雅；
- 你可以用 信道，但是要知道有多少個 goroutine，但是遞回你怎么可能知道有多少個呢？而且也不優雅，
那么就出現了我們的 sync.WaitGroup，非常有用，用法也很簡單：
-
wg.Add(n)，給 counter 加上 n 個計數，
-
wg.Done() 給 counter 減少一個計數，一般是在 goroutine 函式中使用 defer 優雅處理，
-
wg.Wait()，在主執行緒中呼叫，在 counter 變為 0 之前都會阻塞，
坑也很多： -
使用
var wg sync.WaitGroup后 wg 不是指標，傳入函式引數的時候要傳入&wg，但是傳入后在遞回的再次呼叫該函式的時候，由于已經是*sync.WaitGroup型別，就不能再加&了，func recursion(depth int, wg *sync.WaitGroup) { if depth == 0 { return } for i := 0; i < 10; i++ { go recursion(depth - 1, wg) // 不能加 & } } func main() { depth := 10 var wg sync.WaitGroup go recursion(depth, &wg) // 記得加 & } -
wg.Add()和wg.Done()的用法：拿上面的代碼做例子，你是不是以為應該這么寫：func recursion(depth int, wg *sync.WaitGroup) { wg.Add(1) // 每次呼叫都是一個新的 goroutine，所以加一個 counter defer wg.Done() // 呼叫完畢就減少一個 counter if depth == 0 { return } for i := 0; i < 10; i++ { go recursion(depth - 1, wg) } } func main() { depth := 10 var wg sync.WaitGroup go recursion(depth, &wg) wg.Wait() }- 當然大錯特錯，錯炸了，你發現運行錯誤，你發現很多博客的用法都是在主執行緒中使用
wait.Add()，你以為只能在主執行緒中使用，然后你就納悶了，這樣有什么意義，那還怎么知道遞回了多少次？當然，wait.Add()肯定是要在 goroutine 中用的，全是網上搜的博客誤人子弟（我就被他們坑了好幾個小時，真的坑），
- 當然大錯特錯，錯炸了，你發現運行錯誤，你發現很多博客的用法都是在主執行緒中使用
-
你的錯誤在于對這里 goroutine 的數量的判斷錯誤，來看看正確答案，其實只改了三行：
func recursion(depth int, wg *sync.WaitGroup) { defer wg.Done() // 呼叫完畢就減少一個 counter if depth == 0 { return } for i := 0; i < 10; i++ { wg.Add(1) // go 關鍵字在這里，goroutine 是在這里生成的，當然要在這里加 go recursion(depth - 1, wg) } } func main() { depth := 10 var wg sync.WaitGroup wg.add(1) // 每次看到 go 關鍵字之前，就應該呼叫 wg.Add() go recursion(depth, &wg) wg.Wait() }- goroutine 是怎么產生的，是通過 go 關鍵字產生的，那么問題就好解決了，剛剛那段代碼的問題在于，每次呼叫都執行了 10 次 go，產生了 10 個 goroutine，但是卻只加了一個 counter，以及主執行緒其實也有一個 goroutine，但是你卻沒有把這個 counter 加上去，
- 這里還挺難的，因為不同遞回函式有不同的產生 goroutine 的方式，每次都要去理清遞回了幾次，在哪里加，說實話，挺難的，
- 但是我總結了一個方法，那就是一旦看到 go 關鍵字，那么在這之前就需要呼叫
wg.Add()，希望這方法能夠幫助你更快的理清遞回中的并發數量
-
試試更改上面的代碼，但是代碼依舊正常運行：
func recursion(depth int, wg *sync.WaitGroup) { defer wg.Done() if depth == 0 { return } wg.Add(10) // 我提前知道這里有 10 個 goroutine，就不在回圈里加了 for i := 0; i < 10; i++ { go recursion(depth - 1, wg) } } func main() { depth := 10 var wg sync.WaitGroup // wg.Add(1) ，這一次這里沒有 go 關鍵字，沒有 goroutine 產生，所以不用加了 recursion(depth, &wg) // 這一次，第一次呼叫我故意不加 go 關鍵字，所以這里不用呼叫 `wg.Add(1)` wg.Wait() }
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/285535.html
標籤：Go
上一篇：通用連接池幫你解決資源管理難題