一、Goroutine
Go 協程可以看做成一個輕量級的執行緒，Go 協程相比於執行緒的優勢：
Goroutine 的成本更低大小隻有 2 kb 左右，執行緒有幾個兆。
Goroutine 會複用執行緒，比如說：我有 100 個協程，但是都是共用的的 3 個執行緒。
Goroutine 之間通訊是通過 channel 通訊的。（Go 推崇的是通道通訊，而不推崇用共享變數通訊）
1、啟動一個 Goroutine
func test() {
fmt.Println("go go go")
}
func main() {
fmt.Println("主執行緒開始")
// go 關鍵字開啟 Goroutine，一個 Goroutine只佔2kb左右
go test() // 一個 go 就是一個協程，多個就是多個協程，也可以for迴圈起多個協程
go test()
time.Sleep(1*time.Second) // Go 語言中主執行緒不會等待Goroutine執行完成，要等待它結束需要自己處理
fmt.Println("主執行緒結束")
}
// 輸出：
主執行緒開始
go go go
go go go
主執行緒結束
2、Go 語言的GMP模型
G：就是我們開起的 Goroutine
- 它們會被相對平均的放到 P 的佇列中
M：M 可以當成作業系統真正的執行緒，但是實際上是使用者態的執行緒（使用者執行緒）
- 雖然 M 執行 G，但是實際上，M 只是對映到作業系統的執行緒上執行的
- 然後作業系統的排程器把真正的作業系統的執行緒排程到CPU上執行
P：Processor 1.5版本以後預設情況是 CPU 核數（可以當做CPU核數）
- P 會和 M 做互動，真正執行的是 M 在執行 G ，只不過 P 是在做排程
- 一旦某個 G 阻塞了，那麼 P 就會把它排程成下一個 G，放到 M 裡面去執行
使用者執行緒作業系統執行緒：
在 Python 中，使用者執行緒跟作業系統執行緒是 1:1 的對應關係
Go 語言中，使用者執行緒和作業系統執行緒是 m：n 的關係
二、通道
通道（Channel）也就是 Go 協程之間的通訊管道，一端傳送一端接收。
func main() {
// 1、定義 channel
var c chan int
// 2、管道的零值
//———>空值為 nil 說明是引用型別，當做引數傳遞時，不需要取地址，改的就是原來的，需要初始化在使用
fmt.Println(c) // 輸出：<nil>
// 3、管道初始化
c = make(chan int)
go test(c) // c 是引用型別直接傳
// 4、從通道中取值，通道預設不管放值還是取值，都是阻塞的
count := <-c // 阻塞
fmt.Println(count)
/*
當程式執行 go test(c) 時就開了一個 Goroutine
然後繼續執行到 count := <-c 從通道取值，這時就阻塞住了
它會等待 Goroutine 往通道中放值後才會取出值，才會繼續執行 fmt.Println(count)
*/
}
func test(c chan int) {
fmt.Println("GO GO GO")
time.Sleep(1 * time.Second)
// 5、往通道中放一個值，通道預設不管放值還是取值，都是阻塞的
c <- 1 // 阻塞
}
// 輸出：
<nil>
GO GO GO
1
1、死鎖
當 Goroutine 給一個通道放值的時候，按理會有其他 Goroutine 來接收資料，沒有的話就會形成死鎖。
func main() {
c := make(chan int)
c <- 1
}
// 報錯：應為沒有其他 Goroutine 從 c 中取值
2、單向通道
顯而易見就是隻能讀或者只能寫的通道
方式一：
func WriteOnly(c chan<- int) {
c <- 1
}
func main() {
write := make(chan<- int) // 只寫通道
go WriteOnly(write)
fmt.Println(<-write) // 報錯 ——>只寫通道往外取就報錯
}
方式二：
func WriteOnly(c chan<- int) {
c <- 1
// <-c // 報錯
}
func main() {
write := make(chan int) // 定義一個可讀可寫通道
go WriteOnly(write) // 傳到函式中就成了只寫通道，在Goroutine中只負責寫，不能往外讀
fmt.Println(<-write) // 主協程讀
}
3、for 迴圈通道
for 迴圈迴圈通道，如果不關閉，會報死鎖，如果關閉了，放不進去，迴圈結束。
func producer(chnl chan int) {
for i := 0; i < 10; i++ {
chnl <- i // i 放入通道
}
close(chnl) // 關閉通道
}
func main() {
ch := make(chan int)
go producer(ch)
// 迴圈獲取通道內容
for value := range ch {
fmt.Println(value)
}
}
/*
當 for 迴圈 range ch 的時候通道沒有值，會阻塞等待 go producer(ch) 開起的 Goroutine 中放入值
當 Goroutine 中放入一個值，就會阻塞，那麼 range ch 就會取出一個值，然後再次阻塞等待
直到 Goroutine 放入值完畢關閉通道，for 迴圈 range ch 也就結束迴圈了
*/
4、緩衝通道
在預設情況下通道是阻塞的，緩衝通道也就是說我通道里面可以緩衝一些東西，可以不阻塞了。
只有在緩衝已滿的情況，才會阻塞通道
只有在緩衝為空的時候，才會阻塞主緩衝通道接收資料
func main() {
// 指定的數字就是緩衝大小
var c chan int = make(chan int, 3) // 無緩衝通道數字是0
c <- 1
c <- 2
c <- 3
c <- 4 // 緩衝滿了，死鎖
<-c
<-c
<-c
<-c // 取空了，死鎖
fmt.Println(len(c)) // 長度：目前放了多少
fmt.Println(cap(c)) // 容量：可以最多放多少
}
5、WaitGroup
等待所有 Goroutine 執行完成
func process1(i int, wg *sync.WaitGroup) {
fmt.Println("started Goroutine ", i)
time.Sleep(2 * time.Second)
fmt.Printf("Goroutine %d ended\n", i)
// 3、一旦有一個完成，減一
wg.Done()
}
func main() {
var wg sync.WaitGroup // 沒有初始化，值型別，當做引數傳遞，需要取地址
for i := 0; i < 10; i++ {
wg.Add(1) // 1、啟動一個 Goroutine，add 加 1
go process1(i, &wg) // 2、把wg傳過去，因為要改它並且它是值型別需要取地址傳過去
}
wg.Wait() // 4、一直阻塞在這，直到呼叫了10個 Done，計數器減到零
}
6、Select
Select 語句用於在多個傳送 / 接收通道操作中進行選擇。
例如：我要去爬百度，我傳送了三個請求去，可能有一些網路原因，或者其他原因，不一定誰先回來，Select 選擇就是誰先回來我先用誰。
場景一：對效能極致的要求，我就可以選擇一個最快的線路執行我最快的功能，就可以用Select來做
場景二：我去拿這個資料的時候，不是一直等在這裡，而是我可以幹一點別的事情，使用死迴圈 Select 的時候加上 default 去做其他事情。
// 模擬去伺服器去取值
func server(ch chan string) {
time.Sleep(3 * time.Second)
ch <- "from server"
}
func main() {
output1 := make(chan string)
output2 := make(chan string)
// 開起兩個協程執行 server
go server(output1)
go server(output2)
select {
case s1 := <-output1: // 阻塞，誰先回來就執行誰
fmt.Println(s1, "output1")
case s2 := <-output2: // 阻塞，誰先回來就執行誰
fmt.Println(s2, "output2")
}
}
7、Mutex
使用鎖的場景：多個 Goroutine 通過共享記憶體來實現資料通訊，就會出現併發安全的問題，併發安全的問題就需要加鎖。
臨界區：當程式併發執行時修改共享資源的程式碼，也就同一塊記憶體的變數的時候，這些修改的資源的程式碼就稱為臨界區。
如果在任意時刻只允許一個 Goroutine 訪問臨界區，那麼就可以避免競爭條件，而使用 Mutex（鎖） 可以實現
不加用鎖的情況下：
var x = 0 //全域性，各個 Goroutine 都可以拿到並且操作
func increment(wg *sync.WaitGroup) {
x = x + 1
wg.Done()
}
func main() {
var w sync.WaitGroup
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w)
}
w.Wait()
fmt.Println("最終的值：", x)
}
// 輸出：理想情況下是1000，因為併發有安全的問題，所以資料亂了
最終的值： 978
加鎖的情況：
var x = 0 //全域性，各個 Goroutine 都可以拿到並且操作
func increment(wg *sync.WaitGroup, m *sync.Mutex) {
m.Lock() // 加鎖
x = x + 1 // 同一時間只能有一個 Goroutine 執行
m.Unlock() // 解鎖
wg.Done()
}
func main() {
var w sync.WaitGroup
var m sync.Mutex // 因為是個值型別，函式傳遞需要傳地址
fmt.Println(m) // 輸出：{0 0} ——>值型別
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w, &m)
}
w.Wait()
fmt.Println("最終的值：", x)
}
// 輸出：
最終的值： 1000
使用通道來實現：
var x = 0
func increment(wg *sync.WaitGroup, ch chan bool) {
ch <- true // 緩衝通道放滿了，就會阻塞。
x = x + 1
<-ch // 執行完了就取出
wg.Done()
}
func main() {
var w sync.WaitGroup
ch := make(chan bool, 1) // 定義了一個有快取大小為1的通道
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w, ch)
}
w.Wait()
fmt.Println("最終的值：", x)
}
// 輸出：
最終的值：1000
總結：不同 Goroutine 之間傳遞資料的方式：共享變數、通道。
如果是修改變數，傾向於用 Mutex
如果是 Goroutine 之間通訊，傾向於用通道
三、異常處理
defer：延時執行，並且即便程式出現嚴重錯誤，也會執行
func main() {
defer fmt.Println("我最後執行")
defer fmt.Println("我倒數第三執行")
fmt.Println("我先執行")
var a []int
fmt.Println(a[10]) // 報錯
fmt.Println("後執行") // 不會執行了
}
// 輸出：
我先執行
我倒數第三執行
我最後執行
panic: runtime error: index out of range [10] with length 0
panic：主動丟擲異常
recover：恢復程式，繼續執行
func f1() {
fmt.Println("f1 f1")
}
func f2() {
defer func() { // 這個匿名函式永遠會執行
//如果沒有錯誤，執行 recover 會返回 nil，如果有錯誤執行 recover 會返回錯誤資訊
if error := recover(); error != nil {
// 表示出錯了，列印一下錯誤資訊，程式恢復了，繼續執行
fmt.Println(error)
}
fmt.Println("我永遠會執行，不管是否出錯")
}()
fmt.Println("f2 f2")
panic("主動丟擲錯誤")
}
func f3() {
fmt.Println("f3 f3")
}
func main() {
//捕獲異常，處理異常，讓程式繼續執行
f1()
f2()
f3()
}
Go 語言異常捕獲與 Python 異常捕獲對比
Python：
try:
可能會錯誤的程式碼
except Exception as e：
print(e)
finally：
無論是否出錯，都會執行的程式碼
Go ：
defer func() {
if error:=recover();error!=nil{
// 錯誤資訊 error
fmt.Println(error)
}
相當於finally，無論是否出錯，都會執行的程式碼
}()
可能會錯誤的程式碼