一、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，無論是否出錯，都會執行的代碼
}()
可能會錯誤的代碼