Go 語言的併發和並行原理
探究go語言的併發和並行原理。
原文地址: https://github.com/googege/blog/tree/master/go/go/concurrency/README.md
goroutine基於執行緒池的P:M:G協程模型
首先說明一下go可以有兩種併發方式
-
csp
也就是最常使用的go併發模式，這中模式無資訊的直接交換，所以go中運用了chanel來交換資料
-
共享記憶體
通常意義上可以理解為通過共享了記憶體進而來通訊的併發方式，例如加lock
這種模式可以直接交換資料，但是為了併發安全需要加鎖
只有cpu中執行緒之間的資料交換才可以是共享記憶體，程序之間是無法進行資訊交換的
首先我們談談關於cpu和作業系統執行緒，程序的那些事：
我們通常都聽過這個一個詞，cpu 4核8執行緒，這裡的意思就是cpu實際核心是4核，但是在作業系統看來是8核cpu，這裡的8執行緒就是指的是8個虛擬核心。然後再作業系統層面，劃分為程序和執行緒，這裡的程序是cpu資源分配（io儲存等）的基本單位，線上程出現之前它也是cpu進行排程分配的基本單位，注意這裡的執行緒是作業系統的概念，跟4核8執行緒裡的概念不是一回事，而協程也就是coroutine是程式語言層面上的最近才有的一個東西，go裡面的goroutine也可以看做是能實現併發的協程
我們知道，在作業系統的層面上而言，實現併發就是多個執行緒在一個cpu核心裡接替執行，如果是並行呢，就是多個執行緒在多個cpu核心裡同時執行，這裡的同時才是真同時，而併發是"肉眼可見的同時但 是光速裡的交替執行"如果是高cpu密集計算形式的任務其實不需要那麼多個執行緒，只需要幾個執行緒然後將他們分配到多個核心進行計算，這樣上下文排程的時間就少了非常多了，多io形式的不需要多核，單核多執行緒就足夠了,因為在跨執行緒之間的資料交換上下文切換花費的時間也不少。
go實現併發的模式是PMG
如圖：
image
p就是上下文context m就是machine也就是對應著作業系統執行緒 g就是goroutine 我們來看看對應的關係
首先m對應了一個kse也就是作業系統中的一個執行緒，然後這個m下面有一個p就是上下文排程，然後這個p上面有一個初始的g goroutine和一個佇列，這個佇列裡是一批的goroutine，這個就是PMG模型。這裡有無數個想這樣的單位，如果誰的活幹完了那麼它就會去搶奪別的佇列的東西，並且分走一半的任務。
其實 goroutine 用到的就是執行緒池的技術，當 goroutine 需要執行時，會從 thread pool 中選出一個可用的 M 或者新建一個 M。而 thread pool 中如何選取執行緒，擴建執行緒，回收執行緒，Go 排程器 進行了封裝，對程式透明，只管呼叫就行，從而簡化了thread pool 的使用，它是定義在proc.c中，它維護有儲存M和G的佇列以及排程器的一些狀態資訊
- 問 什麼時候會建立另一個kse呢？（作業系統的執行緒）
我們可以這麼看這個模型，一個地鼠推著一個車子，車子上是磚頭，地鼠就是m車子就是p磚頭就是g而m對應了一個kse，那麼什麼時候會建立另一個m呢？runtime什麼時候建立執行緒？磚(G)太多了，地鼠(M)又太少了，實在忙不過來，剛好還有空閒的小車(P)沒有使用 當這個地鼠發現自己的活太多的時候，排程器就會再啟動一個m也就是執行緒池的概念，在作業系統層面從這個池中重新分配一個kse讓他繼續幹活。如果一個m發現自己沒活了，那麼它會主動去攬活兒，如果發現沒活了那麼它就會去偷取同伴m的g，直接拿走一半，如果同伴也沒了，那麼它就去睡覺了，也就是sleep了，
- go的GOMAXPROCS 是幹嘛的？
在go語言啟動的時候會首先檢視gomaxprocs，它會根據設定的數量來建立一批p，然後將他們儲存在排程器裡，以連結串列的方式儲存。它就是小推車呀
- 解析goroutine協程和kse的關係
上面說了輕量級kse（作業系統執行緒）才是cpu排程的基本單位，你goroutine算什麼？，然後剛說了mpg，m就是這個kse p就是上下文，g就是goruntine，當然除此之外，go還有一個排程器然後go在這個kse中模擬了執行緒執行的過程，讓p負責管理，這個時候p沒辦法主動去取消g，只能g執行完了主動告訴p說我執行完了然後p把狀態儲存到棧上，然後執行另一個g，等到所有的g都執行完都返回了，就跟剛才說的一樣這個m開始去取新的任務了，或者就是將p還給排程器然後自己休息了。
- cpu執行的時候能同時執行多個程序嗎？
答案是不行，cpu去執行程序的時候只能去操作這個程序中的多個執行緒，然後將這些個執行緒分配到不同的cpu核心中。它是無法去執行多個程序的
因為cpu同時只能執行一個程序。
- cpu同時只能執行一個程序，那麼我的計算機裡為什麼可以同時執行多個程式呢？
作業系統排程器（區分於go中的排程器哦） 拆分CPU為一段段時間的執行片，輪流分配給不同的程式。這樣的話就彷彿可以同時執行不同的程式程序了，還記得你使用 kill 命令的時候嗎？殺的就是程序，這些程序不能同時執行，他們被分配到不同的cpu片段裡。
- 為什麼除了作業系統排程器go還有一個自己的排程器
單獨的開發一個GO得排程器，可以是其知道在什麼時候記憶體狀態是一致的，也就是說，當開始垃圾回收時，執行時只需要為當時
正在CPU核上執行的那個執行緒等待即可，而不是等待所有的執行緒。不然如果只有os的排程器，那gc的時候就要全部停下了。
綜上所述：
-
cpu同時只能執行一個程式（作業系統kse程序）（例如同時執行一個go程式然後接下來再單獨執行一個qq）但是作業系統將cpu分為了多時間片段，並且速度夠快，所以你看起來就是同時執行嘍
-
cpu可以將這個程序中的很多執行緒分配到不同的cpu核心裡。這樣就實現了並行，因為它只能識別一個程序，但是程序中有很多執行緒。
-
執行緒池的概念在go中主要是用於分配那個m，並且是go自己的排程器來分配的
-
GOMAXPROCS的功能是為了分配p也就是車子，分配好了車子就儲存在排程器中，m可多可少，但是車是一定的。
-
在這個車子中g的數量可多可少，可以非常多，那麼m也就是這個kse是根據GOMAXPROCS來定的，他的數量<= GOMAXPROCS指定的數量，但是最多不能超過256（不論你的gomaxpocs設定的是多少）
-
cpu將這個m也就是作業系統執行緒分配到多個cpu核心中
-
如果GOMAXPROCS設定是1 那麼只能講這個執行緒分配到一個cpu核心中了，因為只有一個執行緒，（p只有一個，當然m也是隻有一個）所以就是併發不能並行了
-
上下文context 也就是p 管理著這裡面一個佇列的的很多個的goroutine，所以這麼說來，p是控制區域性G的排程器也可以這麼說，但是它不能主動控制g，是g說我執行完了，告訴它而已。但是和go自己的本身的排程器不是一回事兒。go本身的排程器實現了很多功能例如說分配M.
-
go單獨於os的排程器也就是區別於os的排程器 它是管理這個執行緒池的 --- 管理如何分配m
channel 基於生產者消費者模型的無鎖佇列
首先解釋一下什麼是生產者消費者模式：
有三個東西，生產資料的一個任務（可以是執行緒，程序函式等）一個快取區域，一個使用資料的任務這個模式基本上可以類比：廚師做飯+把飯放到前臺+你去端飯。
還記得上文談的csp模型嗎？這裡的channel就是csp中通訊的部分，上文的goroutine是併發實體
channel的建立是使用的make，那麼這說明了什麼？說明了channel的初始值肯定是nil，channel變數是一個引用變數（具體是一個struct的指標）
channel分為兩種：無快取的channel和有快取的channel什麼區別呢？無快取的就是有東西就需要讀，不讀就沒法再往裡面加東西,有快取的就是不讀也能繼續加東西。就這麼個區別。Channel是Go中的一個核心型別，你可以把它看成一個管道，通過它併發核心單元就可以傳送或者接收資料進行通訊。
net.conn 基於epoll的非同步io同步阻塞模型
epoll是Linux為了替代poll模型而打造的支援高併發的產物，net.conn基於這個模型進行打造。其實就是go呼叫了Linux的epoll模型來打造的net.conn，同步阻塞 其實就是呼叫多goroutine+非快取的channel來實現。
syscall 基於作業系統的原生syscall能力
go語言裡的讀取都可以使用作業系統提供的syscall功能，幾乎所有 Linux 檔案相關係統呼叫，Go 都有封裝
net/http基於goroutine的http伺服器
在看原始碼的時候可以看出來每個請求，go都會啟動一個goroutine來進行服務。這個就是go net.Listen高併發的關鍵。
併發安全的hash map slice
在syscall.map中提供了這個併發安全的map，如果不使用這個原生的map在跨goroutine就可能發生資源搶斷的問題，沒有這個函式的時候,使用lock unlock也可以實現相關的功能。
可實現cas context基於channel的goroutine流程控制能力
context包，是go新增的一個包，這個包主要的目的是提供一個上下文，我們可以使用這個包來實現goroutine之間的一些調配
舉個例子 當a goroutine裡新增一個b groutine，那麼當a執行5分鐘後要求b結束，該怎麼做呢？
使用ctx.WitchTimeOut 就給b傳送訊號，讓它關閉，看個例子
func main(){
ctx,cal := context.WithTimeout(context.Background(),5*time.Second)
ctx = context.WithValue(ctx,"12","12")
go b(ctx)
time.Sleep(1e10)
cal()// 執行取消命令
time.Sleep(1e10)
}
func b(ctx context.Context) {
for {
time.Sleep(time.Second)
select {
case <-ctx.Done():
fmt.Println(ctx.Value("12"))
return
default:
fmt.Println(".")
}
}
}
// output:
/*
.
.
.
.
12
*/
以實現有限的動態性 atomic基於cpu原子操作的包裝
atomic包的所有動作都是基於cpu的原子操作，atomic 提供的原子操作能夠確保任一時刻只有一個goroutine對變數進行操作
這樣的話就可以避免在程式中出現的大量lock unlock的現象了。你可以理解為atomic是輕量級的鎖
gosched 基於阻塞的協程排程
Gosched產生處理器，允許其他goroutines執行。它不會掛起當前的goroutine，因此執行會自動恢復。
這句話的意思就是，遇到這個go.Gosched,這個goroutine就會讓出執行的機會給其它的goruntine。
go gc基於三色標記法的併發gc模型
go的垃圾回收和正在執行的邏輯goruntine不是同一個goroutine，這些goroutine是分別佔用cpu時間片段的，這就導致go 的執行中gc的時候go程式並不是都停止的，（gc需要記憶體保持一致，需要停止）如果一個記憶體物件在一次GC迴圈開始的時候無法被訪問，則將會被凍結，並在GC的最後將其回收。
中心思想就是
根節點設定咋白色區域內，然後子程式在灰色區域中，然後gc掃描記憶體物件，將其設定為黑色，當然他的子程式也是在灰色中，將白色區域中沒有任務的變量回收了，然後將灰色區域中沒有引用依賴的記憶體物件移動到黑色區域中，然後灰色區域中的不可達的的程式將會在下一次gc的時候被收回，然後 這個黑色的區域直接變成白色，進行下一次迴圈。
總結
- 根節點在白色區域
- 子程式在灰色區域
- 將白色區域沒有用的變量回收
- 將灰色區域中的沒有引用依賴的（說白了 無依無靠沒有什麼指向的）變數或者是什麼程式之類的送到黑色區域
- 然後灰色區域的變數如果這次無法回收，就下次gc回收
- 進行下一次迴圈。
- gc過程和正常執行的邏輯程式碼並行執行。