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

學習之旅

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/308237.html

標籤：其他

上一篇：現代 C++ 對多執行緒/并發的支持（上） -- 節選自 C++ 之父的《A Tour of C++》

下一篇：資料結構與演算法(二)

Go語言之Goroutine與信道、例外處理