go併發和並行

Go語言的併發和並行

不知道你有沒有注意到一個現象，仍是這段代碼，若是我跑在兩個goroutines裏面的話:

var quit chan int = make(chan int) func loop() { for i := 0; i < 10; i++ { fmt.Printf("%d ", i) } quit <- 0 } func main() { // 開兩個goroutine跑函數loop, loop函數負責打印10個數 go loop() go loop() for i := 0; i < 2; i++ { <- quit } } 

咱們觀察下輸出:

這是否是有什麼問題？?

 

之前咱們用線程去作相似任務的時候，系統的線程會搶佔式地輸出， 表現出來的是亂序地輸出。而goroutine爲何是這樣輸出的呢？

goroutine是在並行嗎？

咱們找個例子測試下:

package main import "fmt" import "time" var quit chan int func foo(id int) { fmt.Println(id) time.Sleep(time.Second) // 停頓一秒 quit <- 0 // 發消息：我執行完啦！ } func main() { count := 1000 quit = make(chan int, count) // 緩衝1000個數據 for i := 0; i < count; i++ { //開1000個goroutine go foo(i) } for i :=0 ; i < count; i++ { // 等待全部完成消息發送完畢。 <- quit } } 

讓咱們跑一下這個程序(之因此先編譯再運行，是爲了讓程序跑的儘可能快,測試結果更好):

咱們看到，總計用時接近一秒。 貌似並行了！

 

咱們須要首先考慮下什麼是併發, 什麼是並行

並行和併發

從概念上講，併發和並行是不一樣的, 簡單來講看這個圖片(原圖來自這裏)

• 兩個隊列，一個Coffee機器，那是併發
• 兩個隊列，兩個Coffee機器，那是並行

更多的資料： 併發不是並行, 固然Google上有更多關於並行和併發的區別。

那麼回到一開始的疑問上，從上面的兩個例子執行後的表現來看，多個goroutine跑loop函數會挨個goroutine去進行，而sleep則是一塊兒執行的。

這是爲何？

默認地， Go全部的goroutines只能在一個線程裏跑 。

也就是說， 以上兩個代碼都不是並行的，可是都是是併發的。

若是當前goroutine不發生阻塞，它是不會讓出CPU給其餘goroutine的, 因此例子一中的輸出會是一個一個goroutine進行的，而sleep函數則阻塞掉了 當前goroutine, 當前goroutine主動讓其餘goroutine執行, 因此造成了邏輯上的並行, 也就是併發。

真正的並行

爲了達到真正的並行，咱們須要告訴Go咱們容許同時最多使用多個核。

回到起初的例子，咱們設置最大開2個原生線程, 咱們須要用到runtime包(runtime包是goroutine的調度器):

import ( "fmt" "runtime" ) var quit chan int = make(chan int) func loop() { for i := 0; i < 100; i++ { //爲了觀察，跑多些 fmt.Printf("%d ", i) } quit <- 0 } func main() { runtime.GOMAXPROCS(2) // 最多使用2個核 go loop() go loop() for i := 0; i < 2; i++ { <- quit } } 

這下會看到兩個goroutine會搶佔式地輸出數據了。

咱們還能夠這樣顯式地讓出CPU時間：

func loop() { for i := 0; i < 10; i++ { runtime.Gosched() // 顯式地讓出CPU時間給其餘goroutine fmt.Printf("%d ", i) } quit <- 0 } func main() { go loop() go loop() for i := 0; i < 2; i++ { <- quit } } 

觀察下結果會看到這樣有規律的輸出:

其實，這種主動讓出CPU時間的方式仍然是在單核裏跑。但手工地切換goroutine致使了看上去的「並行」。

 

其實做爲一個Python程序員，goroutine讓我更多地想到的是gevent的協程，而不是原生線程。

關於runtime包對goroutine的調度，在stackoverflow上有一個不錯的答案:http://stackoverflow.com/questions/13107958/what-exactly-does-runtime-gosched-do

一個小問題

我在Segmentfault看到了這個問題: http://segmentfault.com/q/1010000000207474

題目說，以下的程序，按照理解應該打印下5次 

package main import ( "fmt" ) func say(s string) { for i := 0; i < 5; i++ { fmt.Println(s) } } func main() { go say("world") //開一個新的Goroutines執行 for { } } 

樓下的答案已經很棒了，這裏Go仍然在使用單核，for死循環佔據了單核CPU全部的資源，而main線和say兩個goroutine都在一個線程裏面， 因此say沒有機會執行。解決方案仍是兩個：

• 容許Go使用多核(手動顯式調動( runtime調度器

  runtime調度器是個很神奇的東西，可是我真是希望它不存在，我但願顯式調度能更爲天然些，多核處理默認開啓。

  關於runtime包幾個函數:

  • Gosched 讓出cpu

  • NumCPU 返回當前系統的CPU核數量

  • 可同時使用的CPU核數

  • Goexit 退出當前goroutine(可是defer語句會照常執行)

  總結

  咱們從例子中能夠看到，默認的, 全部goroutine會在一個原生線程裏跑，也就是隻使用了一個CPU核。

  在同一個原生線程裏，若是當前goroutine不發生阻塞，它是不會讓出CPU時間給其餘同線程的goroutines的，這是Go運行時對goroutine的調度，咱們也可使用runtime包來手工調度。

  本文開頭的兩個例子都是限制在單核CPU裏執行的，全部的goroutines跑在一個線程裏面，分析以下:

  • 對於代碼例子一（loop函數的那個），每一個goroutine沒有發生堵塞(直到quit流入數據), 因此在quit以前每一個goroutine不會主動讓出CPU，也就發生了串行打印
  • 對於代碼例子二（time的那個），每一個goroutine在sleep被調用的時候會阻塞，讓出CPU, 因此例子二併發執行。

  那麼關於咱們開啓多核的時候呢？Go語言對goroutine的調度行爲又是怎麼樣的？

  咱們能夠在Golang官方網站的這裏 找到一句話:

  When a coroutine blocks, such as by calling a blocking system call, the run-time automatically moves other coroutines on the same operating system thread to a different, runnable thread so they won't be blocked.

  也就是說:

  當一個goroutine發生阻塞，Go會自動地把與該goroutine處於同一系統線程的其餘goroutines轉移到另外一個系統線程上去，以使這些goroutines不阻塞

  開啓多核的實驗

  仍然須要作一個實驗，來測試下多核支持下goroutines的對原生線程的分配, 也驗證下咱們所獲得的結論「goroutine不阻塞不放開CPU」。

  實驗代碼以下:

  package main import ( "fmt" "runtime" ) var quit chan int = make(chan int) func loop(id int) { // id: 該goroutine的標號 for i := 0; i < 10; i++ { //打印10次該goroutine的標號 fmt.Printf("%d ", id) } quit <- 0 } func main() { runtime.GOMAXPROCS(2) // 最多同時使用2個核 for i := 0; i < 3; i++ { //開三個goroutine go loop(i) } for i := 0; i < 3; i++ { <- quit } } 

  多跑幾回會看到相似這些輸出(不一樣機器環境不同):

  執行它咱們會發現如下現象:

   

  • 有時會發生搶佔式輸出(說明Go開了不止一個原生線程，達到了真正的並行)
  • 有時會順序輸出, 打印完0再打印1, 再打印2(說明Go開一個原生線程，單線程上的goroutine不阻塞不鬆開CPU)

  那麼，咱們還會觀察到一個現象，不管是搶佔地輸出仍是順序的輸出，都會有那麼兩個數字表現出這樣的現象:

  • 一個數字的全部輸出都會在另外一個數字的全部輸出以前

  緣由是， 3個goroutine分配到至多2個線程上，就會至少兩個goroutine分配到同一個線程裏，單線程裏的goroutine 不阻塞不放開CPU, 也就發生了順序輸出。