并發(fā)是編程里面一個非常重要的概念，Go語言在語言層面天生支持并發(fā)，這也是Go語言流行的一個很重要的原因。

Go語言中的并發(fā)編程

并發(fā)與并行

并發(fā)：同一時間段內(nèi)執(zhí)行多個任務(你在用微信和兩個女朋友聊天)。

并行：同一時刻執(zhí)行多個任務(你和你朋友都在用微信和女朋友聊天)。

Go語言的并發(fā)通過goroutine實現(xiàn)。goroutine類似于線程，屬于用戶態(tài)的線程，我們可以根據(jù)需要創(chuàng)建成千上萬個goroutine并發(fā)工作。goroutine是由Go語言的運行時(runtime)調(diào)度完成，而線程是由操作系統(tǒng)調(diào)度完成。

Go語言還提供channel在多個goroutine間進行通信。goroutine和channel是 Go 語言秉承的 CSP(Communicating Sequential Process)并發(fā)模式的重要實現(xiàn)基礎。

goroutine

在java/c++中我們要實現(xiàn)并發(fā)編程的時候，我們通常需要自己維護一個線程池，并且需要自己去包裝一個又一個的任務，同時需要自己去調(diào)度線程執(zhí)行任務并維護上下文切換，這一切通常會耗費程序員大量的心智。那么能不能有一種機制，程序員只需要定義很多個任務，讓系統(tǒng)去幫助我們把這些任務分配到CPU上實現(xiàn)并發(fā)執(zhí)行呢？

Go語言中的goroutine就是這樣一種機制，goroutine的概念類似于線程，但 goroutine是由Go的運行時(runtime)調(diào)度和管理的。Go程序會智能地將 goroutine 中的任務合理地分配給每個CPU。Go語言之所以被稱為現(xiàn)代化的編程語言，就是因為它在語言層面已經(jīng)內(nèi)置了調(diào)度和上下文切換的機制。

在Go語言編程中你不需要去自己寫進程、線程、協(xié)程，你的技能包里只有一個技能–goroutine，當你需要讓某個任務并發(fā)執(zhí)行的時候，你只需要把這個任務包裝成一個函數(shù)，開啟一個goroutine去執(zhí)行這個函數(shù)就可以了，就是這么簡單粗暴。

使用goroutine

Go語言中使用goroutine非常簡單，只需要在調(diào)用函數(shù)的時候在前面加上go關鍵字，就可以為一個函數(shù)創(chuàng)建一個goroutine。

一個goroutine必定對應一個函數(shù)，可以創(chuàng)建多個goroutine去執(zhí)行相同的函數(shù)。

啟動單個goroutine

啟動goroutine的方式非常簡單，只需要在調(diào)用的函數(shù)(普通函數(shù)和匿名函數(shù))前面加上一個go關鍵字。

舉個例子如下：

這個示例中hello函數(shù)和下面的語句是串行的，執(zhí)行的結(jié)果是打印完Hello Goroutine!后打印main goroutine done!。

接下來我們在調(diào)用hello函數(shù)前面加上關鍵字go，也就是啟動一個goroutine去執(zhí)行hello這個函數(shù)。

這一次的執(zhí)行結(jié)果只打印了main goroutine done!，并沒有打印Hello Goroutine!。為什么呢？

在程序啟動時，Go程序就會為main()函數(shù)創(chuàng)建一個默認的goroutine。

當main()函數(shù)返回的時候該goroutine就結(jié)束了，所有在main()函數(shù)中啟動的goroutine會一同結(jié)束，main函數(shù)所在的goroutine就像是權利的游戲中的夜王，其他的goroutine都是異鬼，夜王一死它轉(zhuǎn)化的那些異鬼也就全部GG了。

所以我們要想辦法讓main函數(shù)等一等hello函數(shù)，最簡單粗暴的方式就是time.Sleep了。

執(zhí)行上面的代碼你會發(fā)現(xiàn)，這一次先打印main goroutine done!，然后緊接著打印Hello Goroutine!。

首先為什么會先打印main goroutine done!是因為我們在創(chuàng)建新的goroutine的時候需要花費一些時間，而此時main函數(shù)所在的goroutine是繼續(xù)執(zhí)行的。

啟動多個goroutine

在Go語言中實現(xiàn)并發(fā)就是這樣簡單，我們還可以啟動多個goroutine。讓我們再來一個例子： (這里使用了sync.WaitGroup來實現(xiàn)goroutine的同步)

多次執(zhí)行上面的代碼，會發(fā)現(xiàn)每次打印的數(shù)字的順序都不一致。這是因為10個goroutine是并發(fā)執(zhí)行的，而goroutine的調(diào)度是隨機的。

goroutine與線程

可增長的棧

OS線程(操作系統(tǒng)線程)一般都有固定的棧內(nèi)存(通常為2MB),一個goroutine的棧在其生命周期開始時只有很小的棧(典型情況下2KB)，goroutine的棧不是固定的，他可以按需增大和縮小，goroutine的棧大小限制可以達到1GB，雖然極少會用到這個大。所以在Go語言中一次創(chuàng)建十萬左右的goroutine也是可以的。

goroutine調(diào)度

GPM是Go語言運行時(runtime)層面的實現(xiàn)，是go語言自己實現(xiàn)的一套調(diào)度系統(tǒng)。區(qū)別于操作系統(tǒng)調(diào)度OS線程。

• G很好理解，就是個goroutine的，里面除了存放本goroutine信息外 還有與所在P的綁定等信息。
• P管理著一組goroutine隊列，P里面會存儲當前goroutine運行的上下文環(huán)境(函數(shù)指針，堆棧地址及地址邊界)，P會對自己管理的goroutine隊列做一些調(diào)度(比如把占用CPU時間較長的goroutine暫停、運行后續(xù)的goroutine等等)當自己的隊列消費完了就去全局隊列里取，如果全局隊列里也消費完了會去其他P的隊列里搶任務。
• M(machine)是Go運行時(runtime)對操作系統(tǒng)內(nèi)核線程的虛擬， M與內(nèi)核線程一般是一一映射的關系， 一個groutine最終是要放到M上執(zhí)行的；

P與M一般也是一一對應的。他們關系是： P管理著一組G掛載在M上運行。當一個G長久阻塞在一個M上時，runtime會新建一個M，阻塞G所在的P會把其他的G 掛載在新建的M上。當舊的G阻塞完成或者認為其已經(jīng)死掉時 回收舊的M。

P的個數(shù)是通過runtime.GOMAXPROCS設定(最大256)，Go1.5版本之后默認為物理線程數(shù)。 在并發(fā)量大的時候會增加一些P和M，但不會太多，切換太頻繁的話得不償失。

單從線程調(diào)度講，Go語言相比起其他語言的優(yōu)勢在于OS線程是由OS內(nèi)核來調(diào)度的，goroutine則是由Go運行時(runtime)自己的調(diào)度器調(diào)度的，這個調(diào)度器使用一個稱為m:n調(diào)度的技術(復用/調(diào)度m個goroutine到n個OS線程)。 其一大特點是goroutine的調(diào)度是在用戶態(tài)下完成的， 不涉及內(nèi)核態(tài)與用戶態(tài)之間的頻繁切換，包括內(nèi)存的分配與釋放，都是在用戶態(tài)維護著一塊大的內(nèi)存池， 不直接調(diào)用系統(tǒng)的malloc函數(shù)(除非內(nèi)存池需要改變)，成本比調(diào)度OS線程低很多。 另一方面充分利用了多核的硬件資源，近似的把若干goroutine均分在物理線程上， 再加上本身goroutine的超輕量，以上種種保證了go調(diào)度方面的性能。

GOMAXPROCS

Go運行時的調(diào)度器使用GOMAXPROCS參數(shù)來確定需要使用多少個OS線程來同時執(zhí)行Go代碼。默認值是機器上的CPU核心數(shù)。例如在一個8核心的機器上，調(diào)度器會把Go代碼同時調(diào)度到8個OS線程上(GOMAXPROCS是m:n調(diào)度中的n)。

Go語言中可以通過runtime.GOMAXPROCS()函數(shù)設置當前程序并發(fā)時占用的CPU邏輯核心數(shù)。

Go1.5版本之前，默認使用的是單核心執(zhí)行。Go1.5版本之后，默認使用全部的CPU邏輯核心數(shù)。

我們可以通過將任務分配到不同的CPU邏輯核心上實現(xiàn)并行的效果，這里舉個例子：

兩個任務只有一個邏輯核心，此時是做完一個任務再做另一個任務。 將邏輯核心數(shù)設為2，此時兩個任務并行執(zhí)行，代碼如下。

Go語言中的操作系統(tǒng)線程和goroutine的關系：

一個操作系統(tǒng)線程對應用戶態(tài)多個goroutine。

go程序可以同時使用多個操作系統(tǒng)線程。

goroutine和OS線程是多對多的關系，即m:n。

channel

單純地將函數(shù)并發(fā)執(zhí)行是沒有意義的。函數(shù)與函數(shù)間需要交換數(shù)據(jù)才能體現(xiàn)并發(fā)執(zhí)行函數(shù)的意義。

雖然可以使用共享內(nèi)存進行數(shù)據(jù)交換，但是共享內(nèi)存在不同的goroutine中容易發(fā)生競態(tài)問題。為了保證數(shù)據(jù)交換的正確性，必須使用互斥量對內(nèi)存進行加鎖，這種做法勢必造成性能問題。

Go語言的并發(fā)模型是CSP(Communicating Sequential Processes)，提倡通過通信共享內(nèi)存而不是通過共享內(nèi)存而實現(xiàn)通信。

如果說goroutine是Go程序并發(fā)的執(zhí)行體，channel就是它們之間的連接。channel是可以讓一個goroutine發(fā)送特定值到另一個goroutine的通信機制。

Go 語言中的通道(channel)是一種特殊的類型。通道像一個傳送帶或者隊列，總是遵循先入先出(First In First Out)的規(guī)則，保證收發(fā)數(shù)據(jù)的順序。每一個通道都是一個具體類型的導管，也就是聲明channel的時候需要為其指定元素類型。

channel類型

channel是一種類型，一種引用類型。聲明通道類型的格式如下：

var 變量 chan 元素類型

舉幾個例子：

創(chuàng)建channel

通道是引用類型，通道類型的空值是nil。

聲明的通道后需要使用make函數(shù)初始化之后才能使用。

創(chuàng)建channel的格式如下：

make(chan 元素類型, [緩沖大小])

channel的緩沖大小是可選的。

舉幾個例子：

channel操作

通道有發(fā)送(send)、接收(receive)和關閉(close)三種操作。

發(fā)送和接收都使用

現(xiàn)在我們先使用以下語句定義一個通道：

ch := make(chan int)

發(fā)送

將一個值發(fā)送到通道中。

接收

從一個通道中接收值。

關閉

我們通過調(diào)用內(nèi)置的close函數(shù)來關閉通道。

close(ch)

關于關閉通道需要注意的事情是，只有在通知接收方goroutine所有的數(shù)據(jù)都發(fā)送完畢的時候才需要關閉通道。通道是可以被垃圾回收機制回收的，它和關閉文件是不一樣的，在結(jié)束操作之后關閉文件是必須要做的，但關閉通道不是必須的。

關閉后的通道有以下特點：

對一個關閉的通道再發(fā)送值就會導致panic。

對一個關閉的通道進行接收會一直獲取值直到通道為空。

對一個關閉的并且沒有值的通道執(zhí)行接收操作會得到對應類型的零值。

關閉一個已經(jīng)關閉的通道會導致panic。

無緩沖的通道

無緩沖的通道又稱為阻塞的通道。我們來看一下下面的代碼：

上面這段代碼能夠通過編譯，但是執(zhí)行的時候會出現(xiàn)以下錯誤：

為什么會出現(xiàn)deadlock錯誤呢？

因為我們使用ch := make(chan int)創(chuàng)建的是無緩沖的通道，無緩沖的通道只有在有人接收值的時候才能發(fā)送值。就像你住的小區(qū)沒有快遞柜和代收點，快遞員給你打電話必須要把這個物品送到你的手中，簡單來說就是無緩沖的通道必須有接收才能發(fā)送。

上面的代碼會阻塞在ch

一種方法是啟用一個goroutine去接收值，例如：

無緩沖通道上的發(fā)送操作會阻塞，直到另一個goroutine在該通道上執(zhí)行接收操作，這時值才能發(fā)送成功，兩個goroutine將繼續(xù)執(zhí)行。相反，如果接收操作先執(zhí)行，接收方的goroutine將阻塞，直到另一個goroutine在該通道上發(fā)送一個值。

使用無緩沖通道進行通信將導致發(fā)送和接收的goroutine同步化。因此，無緩沖通道也被稱為同步通道。

有緩沖的通道

解決上面問題的方法還有一種就是使用有緩沖區(qū)的通道。我們可以在使用make函數(shù)初始化通道的時候為其指定通道的容量，例如：

只要通道的容量大于零，那么該通道就是有緩沖的通道，通道的容量表示通道中能存放元素的數(shù)量。就像你小區(qū)的快遞柜只有那么個多格子，格子滿了就裝不下了，就阻塞了，等到別人取走一個快遞員就能往里面放一個。

我們可以使用內(nèi)置的len函數(shù)獲取通道內(nèi)元素的數(shù)量，使用cap函數(shù)獲取通道的容量，雖然我們很少會這么做。

如何優(yōu)雅的從通道循環(huán)取值

當通過通道發(fā)送有限的數(shù)據(jù)時，我們可以通過close函數(shù)關閉通道來告知從該通道接收值的goroutine停止等待。當通道被關閉時，往該通道發(fā)送值會引發(fā)panic，從該通道里接收的值一直都是類型零值。那如何判斷一個通道是否被關閉了呢？

我們來看下面這個例子：

從上面的例子中我們看到有兩種方式在接收值的時候判斷通道是否被關閉，我們通常使用的是for range的方式。

單向通道

有的時候我們會將通道作為參數(shù)在多個任務函數(shù)間傳遞，很多時候我們在不同的任務函數(shù)中使用通道都會對其進行限制，比如限制通道在函數(shù)中只能發(fā)送或只能接收。

Go語言中提供了單向通道來處理這種情況。例如，我們把上面的例子改造如下：

其中，

• chan

在函數(shù)傳參及任何賦值操作中將雙向通道轉(zhuǎn)換為單向通道是可以的，但反過來是不可以的。

通道總結(jié)

channel常見的異常總結(jié)，如下圖：

關閉已經(jīng)關閉的channel也會引發(fā)panic。

worker pool(goroutine池)

在工作中我們通常會使用可以指定啟動的goroutine數(shù)量–worker pool模式，控制goroutine的數(shù)量，防止goroutine泄漏和暴漲。

一個簡易的work pool示例代碼如下：

select多路復用

在某些場景下我們需要同時從多個通道接收數(shù)據(jù)。通道在接收數(shù)據(jù)時，如果沒有數(shù)據(jù)可以接收將會發(fā)生阻塞。你也許會寫出如下代碼使用遍歷的方式來實現(xiàn)：

這種方式雖然可以實現(xiàn)從多個通道接收值的需求，但是運行性能會差很多。為了應對這種場景，Go內(nèi)置了select關鍵字，可以同時響應多個通道的操作。

select的使用類似于switch語句，它有一系列case分支和一個默認的分支。每個case會對應一個通道的通信(接收或發(fā)送)過程。select會一直等待，直到某個case的通信操作完成時，就會執(zhí)行case分支對應的語句。具體格式如下：

舉個小例子來演示下select的使用：

使用select語句能提高代碼的可讀性。

• 可處理一個或多個channel的發(fā)送/接收操作。
• 如果多個case同時滿足，select會隨機選擇一個。
• 對于沒有case的select{}會一直等待，可用于阻塞main函數(shù)。

并發(fā)安全和鎖

有時候在Go代碼中可能會存在多個goroutine同時操作一個資源(臨界區(qū))，這種情況會發(fā)生競態(tài)問題(數(shù)據(jù)競態(tài))。類比現(xiàn)實生活中的例子有十字路口被各個方向的的汽車競爭；還有火車上的衛(wèi)生間被車廂里的人競爭。

舉個例子：

上面的代碼中我們開啟了兩個goroutine去累加變量x的值，這兩個goroutine在訪問和修改x變量的時候就會存在數(shù)據(jù)競爭，導致最后的結(jié)果與期待的不符。

互斥鎖

互斥鎖是一種常用的控制共享資源訪問的方法，它能夠保證同時只有一個goroutine可以訪問共享資源。Go語言中使用sync包的Mutex類型來實現(xiàn)互斥鎖。 使用互斥鎖來修復上面代碼的問題：

使用互斥鎖能夠保證同一時間有且只有一個goroutine進入臨界區(qū)，其他的goroutine則在等待鎖；當互斥鎖釋放后，等待的goroutine才可以獲取鎖進入臨界區(qū)，多個goroutine同時等待一個鎖時，喚醒的策略是隨機的。

讀寫互斥鎖

互斥鎖是完全互斥的，但是有很多實際的場景下是讀多寫少的，當我們并發(fā)的去讀取一個資源不涉及資源修改的時候是沒有必要加鎖的，這種場景下使用讀寫鎖是更好的一種選擇。讀寫鎖在Go語言中使用sync包中的RWMutex類型。

讀寫鎖分為兩種：讀鎖和寫鎖。當一個goroutine獲取讀鎖之后，其他的goroutine如果是獲取讀鎖會繼續(xù)獲得鎖，如果是獲取寫鎖就會等待；當一個goroutine獲取寫鎖之后，其他的goroutine無論是獲取讀鎖還是寫鎖都會等待。

讀寫鎖示例：

需要注意的是讀寫鎖非常適合讀多寫少的場景，如果讀和寫的操作差別不大，讀寫鎖的優(yōu)勢就發(fā)揮不出來。

sync.WaitGroup

在代碼中生硬的使用time.Sleep肯定是不合適的，Go語言中可以使用sync.WaitGroup來實現(xiàn)并發(fā)任務的同步。 sync.WaitGroup有以下幾個方法：

sync.WaitGroup內(nèi)部維護著一個計數(shù)器，計數(shù)器的值可以增加和減少。例如當我們啟動了N 個并發(fā)任務時，就將計數(shù)器值增加N。每個任務完成時通過調(diào)用Done()方法將計數(shù)器減1。通過調(diào)用Wait()來等待并發(fā)任務執(zhí)行完，當計數(shù)器值為0時，表示所有并發(fā)任務已經(jīng)完成。

我們利用sync.WaitGroup將上面的代碼優(yōu)化一下：

需要注意sync.WaitGroup是一個結(jié)構(gòu)體，傳遞的時候要傳遞指針。

sync.Once

說在前面的話：這是一個進階知識點。

在編程的很多場景下我們需要確保某些操作在高并發(fā)的場景下只執(zhí)行一次，例如只加載一次配置文件、只關閉一次通道等。

Go語言中的sync包中提供了一個針對只執(zhí)行一次場景的解決方案–sync.Once。

sync.Once只有一個Do方法，其簽名如下：

備注：如果要執(zhí)行的函數(shù)f需要傳遞參數(shù)就需要搭配閉包來使用。

加載配置文件示例

延遲一個開銷很大的初始化操作到真正用到它的時候再執(zhí)行是一個很好的實踐。因為預先初始化一個變量(比如在init函數(shù)中完成初始化)會增加程序的啟動耗時，而且有可能實際執(zhí)行過程中這個變量沒有用上，那么這個初始化操作就不是必須要做的。我們來看一個例子：

多個goroutine并發(fā)調(diào)用Icon函數(shù)時不是并發(fā)安全的，現(xiàn)代的編譯器和CPU可能會在保證每個goroutine都滿足串行一致的基礎上自由地重排訪問內(nèi)存的順序。loadIcons函數(shù)可能會被重排為以下結(jié)果：

在這種情況下就會出現(xiàn)即使判斷了icons不是nil也不意味著變量初始化完成了。考慮到這種情況，我們能想到的辦法就是添加互斥鎖，保證初始化icons的時候不會被其他的goroutine操作，但是這樣做又會引發(fā)性能問題。

使用sync.Once改造的示例代碼如下：

關閉channel示例

sync.Once其實內(nèi)部包含一個互斥鎖和一個布爾值，互斥鎖保證布爾值和數(shù)據(jù)的安全，而布爾值用來記錄初始化是否完成。這樣設計就能保證初始化操作的時候是并發(fā)安全的并且初始化操作也不會被執(zhí)行多次。

sync.Map

Go語言中內(nèi)置的map不是并發(fā)安全的。請看下面的示例：

上面的代碼開啟少量幾個goroutine的時候可能沒什么問題，當并發(fā)多了之后執(zhí)行上面的代碼就會報fatal error: concurrent map writes錯誤。

像這種場景下就需要為map加鎖來保證并發(fā)的安全性了，Go語言的sync包中提供了一個開箱即用的并發(fā)安全版map–sync.Map。開箱即用表示不用像內(nèi)置的map一樣使用make函數(shù)初始化就能直接使用。同時sync.Map內(nèi)置了諸如Store、Load、LoadOrStore、Delete、Range等操作方法。

原子操作

代碼中的加鎖操作因為涉及內(nèi)核態(tài)的上下文切換會比較耗時、代價比較高。針對基本數(shù)據(jù)類型我們還可以使用原子操作來保證并發(fā)安全，因為原子操作是Go語言提供的方法它在用戶態(tài)就可以完成，因此性能比加鎖操作更好。Go語言中原子操作由內(nèi)置的標準庫sync/atomic提供。

atomic包

示例

我們填寫一個示例來比較下互斥鎖和原子操作的性能。

atomic包提供了底層的原子級內(nèi)存操作，對于同步算法的實現(xiàn)很有用。這些函數(shù)必須謹慎地保證正確使用。除了某些特殊的底層應用，使用通道或者sync包的函數(shù)/類型實現(xiàn)同步更好。

練習題

使用goroutine和channel實現(xiàn)一個計算int64隨機數(shù)各位數(shù)和的程序。

開啟一個goroutine循環(huán)生成int64類型的隨機數(shù)，發(fā)送到jobChan

開啟24個goroutine從jobChan中取出隨機數(shù)計算各位數(shù)的和，將結(jié)果發(fā)送到resultChan

主goroutine從resultChan取出結(jié)果并打印到終端輸出

為了保證業(yè)務代碼的執(zhí)行性能將之前寫的日志庫改寫為異步記錄日志方式。

原文鏈接：https://www.liwenzhou.com/posts/Go/14_concurrence/

本文作者：李文周

總結(jié)

以上是生活随笔為你收集整理的go语言打印日期_判定是否掌握Go语言的最重要标准：对并发的掌握的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。