本文原文地址:GoLang協程Goroutiney原理與GMP模型詳解
什麼是goroutine
Goroutine是Go語言中的一種輕量級線程，也成為協程，由Go運行時管理。它是Go語言併發編程的核心概念之一。Goroutine的設計使得在Go中實現併發編程變得非常簡單和高效。
以下是一些關於Goroutine的關鍵特性：
- 輕量級：Goroutine的創建和切換開銷非常小。與操作系統級別的線程相比，Goroutine佔用的內存和資源更少。一個典型的Goroutine只需要幾KB的棧空間，並且棧空間可以根據需要動態增長。
- 併發執行：Goroutine可以併發執行多個任務。Go運行時會自動將Goroutine調度到可用的處理器上執行，從而充分利用多核處理器的能力。
- 簡單的語法：啓動一個Goroutine非常簡單，只需要在函數調用前加上go關鍵字。例如，go myFunction()會啓動一個新的Goroutine來執行myFunction函數。
- 通信和同步：Go語言提供了通道（Channel）機制，用於在Goroutine之間進行通信和同步。通道是一種類型安全的通信方式，可以在不同的Goroutine之間傳遞數據。
什麼是協程
協程（Coroutine）是一種比線程更輕量級的併發編程方式。它允許在單個線程內執行多個任務，並且可以在任務之間進行切換，而不需要進行線程上下文切換的開銷。協程通過協作式多任務處理來實現併發，這意味着任務之間的切換是由程序顯式控制的，而不是由操作系統調度的。
以下是協程的一些關鍵特性：
- 輕量級：協程的創建和切換開銷非常小，因為它們不需要操作系統級別的線程管理。
- 非搶佔式：協程的切換是顯式的，由程序員在代碼中指定，而不是由操作系統搶佔式地調度。
- 狀態保存：協程可以在暫停執行時保存其狀態，並在恢復執行時繼續從暫停的地方開始。
- 異步編程：協程非常適合用於異步編程，特別是在I/O密集型任務中，可以在等待I/O操作完成時切換到其他任務，從而提高程序的併發性和效率。
Goroutin就是Go在協程這個場景上的實現。
以下是一個簡單的go goroutine例子，展示瞭如何使用協程：
package main
import (
"fmt"
"sync"
"time"
)
// 定義一個簡單的函數，模擬一個耗時操作
func printNumbers(wg *sync.WaitGroup) {
defer wg.Done() // 在函數結束時調用Done方法
for i := 1; i <= 5; i++ {
fmt.Printf("Number: %d\n", i)
time.Sleep(1 * time.Second) // 模擬耗時操作
}
}
func main() {
var wg sync.WaitGroup
// 啓動一個goroutine來執行printNumbers函數
wg.Add(1)
go printNumbers(&wg)
// 主goroutine繼續執行其他操作
for i := 'A'; i <= 'E'; i++ {
fmt.Printf("Letter: %c\n", i)
time.Sleep(1 * time.Second) // 模擬耗時操作
}
// 等待所有goroutine完成
wg.Wait()
}我們定義了一個名為printNumbers的函數，該函數會打印數字1到5，並在每次打印後暫停1秒。然後，在main函數中，我們使用go關鍵字啓動一個新的goroutine來執行printNumbers函數。同時，主goroutine繼續執行其他操作，打印字母A到E，並在每次打印後暫停1秒。
需要注意的是，主goroutine和新啓動的goroutine是併發執行的。為了確保所有goroutine完成，我們使用sync.WaitGroup來等待所有goroutine完成。我們在啓動goroutine之前調用wg.Add(1)，並在printNumbers函數結束時調用wg.Done()。最後，我們在main函數中調用wg.Wait()，等待所有goroutine完成。這樣可以確保程序在所有goroutine完成之前不會退出。
協程是一種強大的工具，可以簡化併發編程，特別是在處理I/O密集型任務時。
Goroutin實現原理
Goroutine的實現原理包括Goroutine的創建、調度、上下文切換和棧管理等多個方面。通過GPM模型和高效的調度機制，Go運行時能夠高效地管理和調度大量的Goroutine，實現高併發編程。
Goroutine的創建
當使用go關鍵字啓動一個新的Goroutine時，Go運行時會執行以下步驟：
- 分配G結構體：Go運行時會為新的Goroutine分配一個G結構體（G表示Goroutine），其中包含Goroutine的狀態信息、棧指針、程序計數器等。
- 分配棧空間：Go運行時會為新的Goroutine分配初始的棧空間，通常是幾KB。這個棧空間是動態增長的，可以根據需要自動擴展。
- 初始化G結構體：Go運行時會初始化G結構體，將Goroutine的入口函數、參數、棧指針等信息填入G結構體中。
- 將Goroutine加入調度隊列：Go運行時會將新的Goroutine加入到某個P（Processor）的本地運行隊列中，等待調度執行。
Goroutine的調度
Go運行時使用GPM模型（Goroutine、Processor、Machine）來管理和調度Goroutine。調度過程如下：
- P（Processor）：P是Go運行時的一個抽象概念，表示一個邏輯處理器。每個P持有一個本地運行隊列，用於存儲待執行的Goroutine。P的數量通常等於機器的CPU核心數，可以通過runtime.GOMAXPROCS函數設置。
- M（Machine）：M表示一個操作系統線程。M負責實際執行P中的Goroutine。M與P是一對一綁定的關係，一個M只能綁定一個P，但一個P可以被多個M綁定（通過搶佔機制）。M的數量是由Go運行時系統動態管理和確定的。M的數量並不是固定的，而是根據程序的運行情況和系統資源的使用情況動態調整的。通過runtime.NumGoroutine()和runtime.NumCPU()函數，我們可以查看當前的Goroutine數量和CPU核心數。Go運行時對M的數量有一個默認的最大限制，以防止創建過多的M導致系統資源耗盡。這個限制可以通過環境變量GOMAXPROCS進行調整，但通常不需要手動設置。
- G（Goroutine）：代表一個goroutine，它有自己的棧，instruction pointer和其他信息（正在等待的channel等等），用於調度。
- 調度循環：每個P會在一個循環中不斷從本地運行隊列中取出Goroutine，並將其分配給綁定的M執行。如果P的本地運行隊列為空，P會嘗試從其他P的本地運行隊列中竊取Goroutine（工作竊取機制）。
從上圖中看，有2個物理線程M，每一個M都擁有一個處理器P，每一個也都有一個正在運行的goroutine。P的數量可以通過GOMAXPROCS()來設置，它其實也就代表了真正的併發度，即有多少個goroutine可以同時運行。圖中灰色的那些goroutine並沒有運行，而是出於ready的就緒態，正在等待被調度。P維護着這個隊列（稱之為runqueue），Go語言裏，啓動一個goroutine很容易：go function 就行，所以每有一個go語句被執行，runqueue隊列就在其末尾加入一個goroutine，在下一個調度點，就從runqueue中取出（如何決定取哪個goroutine？）一個goroutine執行。
P的數量可以大於器的CPU核心數？
在Go語言中，P（Processor）的數量通常等於機器的CPU核心數，但也可以通過runtime.GOMAXPROCS函數進行調整。默認情況下，Go運行時會將P的數量設置為機器的邏輯CPU核心數。然而，P的數量可以被設置為大於或小於機器的CPU核心數，這取決於具體的應用需求和性能考慮。
調整P的數量，可以使用runtime.GOMAXPROCS函數來設置P的數量。例如：
package main
import (
"fmt"
"runtime"
"sync"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Worker %d starting\n", id)
// 模擬工作負載
for i := 0; i < 1000000000; i++ {
}
fmt.Printf("Worker %d done\n", id)
}
func main() {
// 設置P的數量為機器邏輯CPU核心數的兩倍
numCPU := runtime.NumCPU()
runtime.GOMAXPROCS(numCPU * 2)
var wg sync.WaitGroup
// 啓動多個Goroutine
for i := 1; i <= 10; i++ {
wg.Add(1)
go worker(i, &wg)
}
// 等待所有Goroutine完成
wg.Wait()
fmt.Println("All workers done")
}在這個示例中，我們將P的數量設置為機器邏輯CPU核心數的兩倍。這樣做的目的是為了觀察在不同P數量設置下程序的性能表現。
-
P的數量大於CPU核心數的影響
- 上下文切換增加：當P的數量大於CPU核心數時，可能會導致更多的上下文切換。因為操作系統需要在有限的CPU核心上調度更多的線程（M），這可能會增加調度開銷。
- 資源競爭：更多的P意味着更多的Goroutine可以同時運行，但這也可能導致更多的資源競爭，特別是在I/O密集型任務中。過多的P可能會導致資源爭用，反而降低程序的整體性能。
- 併發性提高：在某些情況下，增加P的數量可以提高程序的併發性，特別是在存在大量阻塞操作（如I/O操作）的情況下。更多的P可以更好地利用CPU資源，減少阻塞時間。
-
P的數量小於CPU核心數的影響
- CPU利用率降低：當P的數量小於CPU核心數時，可能會導致CPU資源未被充分利用。因為P的數量限制了同時運行的Goroutine數量，可能會導致某些CPU核心處於空閒狀態。
- 減少上下文切換：較少的P數量可以減少上下文切換的開銷，因為操作系統需要調度的線程（M）數量減少。這可能會提高CPU密集型任務的性能。
選擇合適的P數量選擇合適的P數量需要根據具體的應用場景和性能需求進行調整。以下是一些建議：
- CPU密集型任務：對於CPU密集型任務，通常將P的數量設置為等於或接近機器的邏輯CPU核心數，以充分利用CPU資源。
- I/O密集型任務：對於I/O密集型任務，可以考慮將P的數量設置為大於CPU核心數，以提高併發性和資源利用率。
- 性能測試和調優：通過性能測試和調優，找到最佳的P數量設置。可以嘗試不同的P數量，觀察程序的性能表現，選擇最優的配置。
Goroutine的上下文切換
Goroutine的上下文切換由Go運行時的調度器管理，主要涉及以下步驟：
- 保存當前Goroutine的狀態：當一個Goroutine被掛起時，Go運行時會保存當前Goroutine的狀態信息，包括程序計數器、棧指針、寄存器等。
- 切換到新的Goroutine：Go運行時會從P的本地運行隊列中取出下一個待執行的Goroutine，並恢復其狀態信息。
- 恢復新的Goroutine的狀態：Go運行時會將新的Goroutine的狀態信息加載到CPU寄存器中，並跳轉到新的Goroutine的程序計數器位置，繼續執行。
Goroutine什麼時候會被掛起？Goroutine會在執行阻塞操作、使用同步原語、被調度器調度、創建和銷燬時被掛起。Go運行時通過高效的調度機制管理Goroutine的掛起和恢復，以實現高併發和高性能的程序執行。瞭解這些掛起的情況有助於編寫高效的併發程序，並避免潛在的性能問題。
- 阻塞操作
當Goroutine執行阻塞操作時，它會被掛起，直到阻塞操作完成。常見的阻塞操作包括：
- I/O操作：如文件讀寫、網絡通信等。
- 系統調用：如調用操作系統提供的阻塞函數。
- Channel操作：如在無緩衝Channel上進行發送或接收操作時，如果沒有對應的接收者或發送者，Goroutine會被掛起。
- 同步原語
使用同步原語（如sync.Mutex、sync.WaitGroup、sync.Cond等）進行同步操作時，Goroutine可能會被掛起，直到條件滿足。例如：
- 互斥鎖（Mutex）：當Goroutine嘗試獲取一個已經被其他Goroutine持有的互斥鎖時，它會被掛起，直到鎖被釋放。
- 條件變量（Cond）：當Goroutine等待條件變量時，它會被掛起，直到條件變量被通知。
- 調度器調度
Go運行時的調度器會根據需要掛起和恢復Goroutine，以實現高效的併發調度。調度器可能會在以下情況下掛起Goroutine：
- 時間片用完：Go調度器使用協作式調度，當一個Goroutine的時間片用完時，調度器會掛起該Goroutine，並調度其他Goroutine執行。
- 主動讓出：Goroutine可以通過調用runtime.Gosched()主動讓出CPU，調度器會掛起該Goroutine，並調度其他Goroutine執行。
- Goroutine的創建和銷燬
- 創建：當一個新的Goroutine被創建時，它會被掛起，直到調度器將其調度執行。
- 銷燬：當一個Goroutine執行完畢或被顯式終止時，它會被掛起並從調度器中移除。
Goroutine的棧管理
Goroutine的棧空間是動態分配的，可以根據需要自動擴展。Go運行時使用分段棧（segmented stack）或連續棧（continuous stack）來管理Goroutine的棧空間：
- 分段棧：在早期版本的Go中，Goroutine使用分段棧。每個Goroutine的棧由多個小段組成，當棧空間不足時，Go運行時會分配新的棧段並鏈接到現有的棧段上。
- 連續棧：在Go 1.3及以後的版本中，Goroutine使用連續棧。每個Goroutine的棧是一個連續的內存塊，當棧空間不足時，Go運行時會分配一個更大的棧，並將現有的棧內容複製到新的棧中。
