本文原文地址:GoLang協(xié)程Goroutiney原理與GMP模型詳解

什么是goroutine

Goroutine是Go語言中的一種輕量級線程，也成為協(xié)程，由Go運行時管理。它是Go語言并發(fā)編程的核心概念之一。Goroutine的設(shè)計使得在Go中實現(xiàn)并發(fā)編程變得非常簡單和高效。

以下是一些關(guān)于Goroutine的關(guān)鍵特性：

• 輕量級：Goroutine的創(chuàng)建和切換開銷非常小。與操作系統(tǒng)級別的線程相比，Goroutine占用的內(nèi)存和資源更少。一個典型的Goroutine只需要幾KB的?？臻g，并且?？臻g可以根據(jù)需要動態(tài)增長。
• 并發(fā)執(zhí)行：Goroutine可以并發(fā)執(zhí)行多個任務(wù)。Go運行時會自動將Goroutine調(diào)度到可用的處理器上執(zhí)行，從而充分利用多核處理器的能力。
• 簡單的語法：啟動一個Goroutine非常簡單，只需要在函數(shù)調(diào)用前加上go關(guān)鍵字。例如，go myFunction()會啟動一個新的Goroutine來執(zhí)行myFunction函數(shù)。
• 通信和同步：Go語言提供了通道（Channel）機制，用于在Goroutine之間進行通信和同步。通道是一種類型安全的通信方式，可以在不同的Goroutine之間傳遞數(shù)據(jù)。

什么是協(xié)程

協(xié)程（Coroutine）是一種比線程更輕量級的并發(fā)編程方式。它允許在單個線程內(nèi)執(zhí)行多個任務(wù)，并且可以在任務(wù)之間進行切換，而不需要進行線程上下文切換的開銷。協(xié)程通過協(xié)作式多任務(wù)處理來實現(xiàn)并發(fā)，這意味著任務(wù)之間的切換是由程序顯式控制的，而不是由操作系統(tǒng)調(diào)度的。

以下是協(xié)程的一些關(guān)鍵特性：

• 輕量級：協(xié)程的創(chuàng)建和切換開銷非常小，因為它們不需要操作系統(tǒng)級別的線程管理。
• 非搶占式：協(xié)程的切換是顯式的，由程序員在代碼中指定，而不是由操作系統(tǒng)搶占式地調(diào)度。
• 狀態(tài)保存：協(xié)程可以在暫停執(zhí)行時保存其狀態(tài)，并在恢復(fù)執(zhí)行時繼續(xù)從暫停的地方開始。
• 異步編程：協(xié)程非常適合用于異步編程，特別是在I/O密集型任務(wù)中，可以在等待I/O操作完成時切換到其他任務(wù)，從而提高程序的并發(fā)性和效率。

Goroutin就是Go在協(xié)程這個場景上的實現(xiàn)。

以下是一個簡單的go goroutine例子，展示了如何使用協(xié)程：

package main

import (
    "fmt"
    "sync"
    "time"
)

// 定義一個簡單的函數(shù)，模擬一個耗時操作
func printNumbers(wg *sync.WaitGroup) {
    defer wg.Done() // 在函數(shù)結(jié)束時調(diào)用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來執(zhí)行printNumbers函數(shù)
    wg.Add(1)
    go printNumbers(&wg)

    // 主goroutine繼續(xù)執(zhí)行其他操作
    for i := 'A'; i <= 'E'; i++ {
        fmt.Printf("Letter: %c\n", i)
        time.Sleep(1 * time.Second) // 模擬耗時操作
    }

    // 等待所有g(shù)oroutine完成
    wg.Wait()
}

我們定義了一個名為printNumbers的函數(shù)，該函數(shù)會打印數(shù)字1到5，并在每次打印后暫停1秒。然后，在main函數(shù)中，我們使用go關(guān)鍵字啟動一個新的goroutine來執(zhí)行printNumbers函數(shù)。同時，主goroutine繼續(xù)執(zhí)行其他操作，打印字母A到E，并在每次打印后暫停1秒。

需要注意的是，主goroutine和新啟動的goroutine是并發(fā)執(zhí)行的。為了確保所有g(shù)oroutine完成，我們使用sync.WaitGroup來等待所有g(shù)oroutine完成。我們在啟動goroutine之前調(diào)用wg.Add(1)，并在printNumbers函數(shù)結(jié)束時調(diào)用wg.Done()。最后，我們在main函數(shù)中調(diào)用wg.Wait()，等待所有g(shù)oroutine完成。這樣可以確保程序在所有g(shù)oroutine完成之前不會退出。

協(xié)程是一種強大的工具，可以簡化并發(fā)編程，特別是在處理I/O密集型任務(wù)時。

Goroutin實現(xiàn)原理

Goroutine的實現(xiàn)原理包括Goroutine的創(chuàng)建、調(diào)度、上下文切換和棧管理等多個方面。通過GPM模型和高效的調(diào)度機制，Go運行時能夠高效地管理和調(diào)度大量的Goroutine，實現(xiàn)高并發(fā)編程。

Goroutine的創(chuàng)建

當使用go關(guān)鍵字啟動一個新的Goroutine時，Go運行時會執(zhí)行以下步驟：

1. 分配G結(jié)構(gòu)體：Go運行時會為新的Goroutine分配一個G結(jié)構(gòu)體（G表示Goroutine），其中包含Goroutine的狀態(tài)信息、棧指針、程序計數(shù)器等。
2. 分配棧空間：Go運行時會為新的Goroutine分配初始的?？臻g，通常是幾KB。這個棧空間是動態(tài)增長的，可以根據(jù)需要自動擴展。
3. 初始化G結(jié)構(gòu)體：Go運行時會初始化G結(jié)構(gòu)體，將Goroutine的入口函數(shù)、參數(shù)、棧指針等信息填入G結(jié)構(gòu)體中。
4. 將Goroutine加入調(diào)度隊列：Go運行時會將新的Goroutine加入到某個P（Processor）的本地運行隊列中，等待調(diào)度執(zhí)行。

Goroutine的調(diào)度

Go運行時使用GPM模型（Goroutine、Processor、Machine）來管理和調(diào)度Goroutine。調(diào)度過程如下：

• P（Processor）：P是Go運行時的一個抽象概念，表示一個邏輯處理器。每個P持有一個本地運行隊列，用于存儲待執(zhí)行的Goroutine。P的數(shù)量通常等于機器的CPU核心數(shù)，可以通過runtime.GOMAXPROCS函數(shù)設(shè)置。
• M（Machine）：M表示一個操作系統(tǒng)線程。M負責實際執(zhí)行P中的Goroutine。M與P是一對一綁定的關(guān)系，一個M只能綁定一個P，但一個P可以被多個M綁定（通過搶占機制）。M的數(shù)量是由Go運行時系統(tǒng)動態(tài)管理和確定的。M的數(shù)量并不是固定的，而是根據(jù)程序的運行情況和系統(tǒng)資源的使用情況動態(tài)調(diào)整的。通過runtime.NumGoroutine()和runtime.NumCPU()函數(shù)，我們可以查看當前的Goroutine數(shù)量和CPU核心數(shù)。Go運行時對M的數(shù)量有一個默認的最大限制，以防止創(chuàng)建過多的M導(dǎo)致系統(tǒng)資源耗盡。這個限制可以通過環(huán)境變量GOMAXPROCS進行調(diào)整，但通常不需要手動設(shè)置。
• G（Goroutine）：代表一個goroutine，它有自己的棧，instruction pointer和其他信息（正在等待的channel等等），用于調(diào)度。

• 調(diào)度循環(huán)：每個P會在一個循環(huán)中不斷從本地運行隊列中取出Goroutine，并將其分配給綁定的M執(zhí)行。如果P的本地運行隊列為空，P會嘗試從其他P的本地運行隊列中竊取Goroutine（工作竊取機制）。

  
  
  image.png

從上圖中看，有2個物理線程M，每一個M都擁有一個處理器P，每一個也都有一個正在運行的goroutine。P的數(shù)量可以通過GOMAXPROCS()來設(shè)置，它其實也就代表了真正的并發(fā)度，即有多少個goroutine可以同時運行。圖中灰色的那些goroutine并沒有運行，而是出于ready的就緒態(tài)，正在等待被調(diào)度。P維護著這個隊列（稱之為runqueue），Go語言里，啟動一個goroutine很容易：go function 就行，所以每有一個go語句被執(zhí)行，runqueue隊列就在其末尾加入一個goroutine，在下一個調(diào)度點，就從runqueue中取出（如何決定取哪個goroutine？）一個goroutine執(zhí)行。

P的數(shù)量可以大于器的CPU核心數(shù)？

在Go語言中，P（Processor）的數(shù)量通常等于機器的CPU核心數(shù)，但也可以通過runtime.GOMAXPROCS函數(shù)進行調(diào)整。默認情況下，Go運行時會將P的數(shù)量設(shè)置為機器的邏輯CPU核心數(shù)。然而，P的數(shù)量可以被設(shè)置為大于或小于機器的CPU核心數(shù)，這取決于具體的應(yīng)用需求和性能考慮。

調(diào)整P的數(shù)量，可以使用runtime.GOMAXPROCS函數(shù)來設(shè)置P的數(shù)量。例如：

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() {
    // 設(shè)置P的數(shù)量為機器邏輯CPU核心數(shù)的兩倍
    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的數(shù)量設(shè)置為機器邏輯CPU核心數(shù)的兩倍。這樣做的目的是為了觀察在不同P數(shù)量設(shè)置下程序的性能表現(xiàn)。

• P的數(shù)量大于CPU核心數(shù)的影響
  • 上下文切換增加：當P的數(shù)量大于CPU核心數(shù)時，可能會導(dǎo)致更多的上下文切換。因為操作系統(tǒng)需要在有限的CPU核心上調(diào)度更多的線程（M），這可能會增加調(diào)度開銷。
  • 資源競爭：更多的P意味著更多的Goroutine可以同時運行，但這也可能導(dǎo)致更多的資源競爭，特別是在I/O密集型任務(wù)中。過多的P可能會導(dǎo)致資源爭用，反而降低程序的整體性能。
  • 并發(fā)性提高：在某些情況下，增加P的數(shù)量可以提高程序的并發(fā)性，特別是在存在大量阻塞操作（如I/O操作）的情況下。更多的P可以更好地利用CPU資源，減少阻塞時間。
• P的數(shù)量小于CPU核心數(shù)的影響
  • CPU利用率降低：當P的數(shù)量小于CPU核心數(shù)時，可能會導(dǎo)致CPU資源未被充分利用。因為P的數(shù)量限制了同時運行的Goroutine數(shù)量，可能會導(dǎo)致某些CPU核心處于空閑狀態(tài)。
  • 減少上下文切換：較少的P數(shù)量可以減少上下文切換的開銷，因為操作系統(tǒng)需要調(diào)度的線程（M）數(shù)量減少。這可能會提高CPU密集型任務(wù)的性能。

選擇合適的P數(shù)量選擇合適的P數(shù)量需要根據(jù)具體的應(yīng)用場景和性能需求進行調(diào)整。以下是一些建議：

• CPU密集型任務(wù)：對于CPU密集型任務(wù)，通常將P的數(shù)量設(shè)置為等于或接近機器的邏輯CPU核心數(shù)，以充分利用CPU資源。
• I/O密集型任務(wù)：對于I/O密集型任務(wù)，可以考慮將P的數(shù)量設(shè)置為大于CPU核心數(shù)，以提高并發(fā)性和資源利用率。
• 性能測試和調(diào)優(yōu)：通過性能測試和調(diào)優(yōu)，找到最佳的P數(shù)量設(shè)置?？梢試L試不同的P數(shù)量，觀察程序的性能表現(xiàn)，選擇最優(yōu)的配置。

Goroutine的上下文切換

Goroutine的上下文切換由Go運行時的調(diào)度器管理，主要涉及以下步驟：

• 保存當前Goroutine的狀態(tài)：當一個Goroutine被掛起時，Go運行時會保存當前Goroutine的狀態(tài)信息，包括程序計數(shù)器、棧指針、寄存器等。
• 切換到新的Goroutine：Go運行時會從P的本地運行隊列中取出下一個待執(zhí)行的Goroutine，并恢復(fù)其狀態(tài)信息。
• 恢復(fù)新的Goroutine的狀態(tài)：Go運行時會將新的Goroutine的狀態(tài)信息加載到CPU寄存器中，并跳轉(zhuǎn)到新的Goroutine的程序計數(shù)器位置，繼續(xù)執(zhí)行。

Goroutine什么時候會被掛起？Goroutine會在執(zhí)行阻塞操作、使用同步原語、被調(diào)度器調(diào)度、創(chuàng)建和銷毀時被掛起。Go運行時通過高效的調(diào)度機制管理Goroutine的掛起和恢復(fù)，以實現(xiàn)高并發(fā)和高性能的程序執(zhí)行。了解這些掛起的情況有助于編寫高效的并發(fā)程序，并避免潛在的性能問題。

1. 阻塞操作

當Goroutine執(zhí)行阻塞操作時，它會被掛起，直到阻塞操作完成。常見的阻塞操作包括：

• I/O操作：如文件讀寫、網(wǎng)絡(luò)通信等。
• 系統(tǒng)調(diào)用：如調(diào)用操作系統(tǒng)提供的阻塞函數(shù)。
• Channel操作：如在無緩沖Channel上進行發(fā)送或接收操作時，如果沒有對應(yīng)的接收者或發(fā)送者，Goroutine會被掛起。

2. 同步原語

使用同步原語（如sync.Mutex、sync.WaitGroup、sync.Cond等）進行同步操作時，Goroutine可能會被掛起，直到條件滿足。例如：

• 互斥鎖（Mutex）：當Goroutine嘗試獲取一個已經(jīng)被其他Goroutine持有的互斥鎖時，它會被掛起，直到鎖被釋放。
• 條件變量（Cond）：當Goroutine等待條件變量時，它會被掛起，直到條件變量被通知。

3. 調(diào)度器調(diào)度

Go運行時的調(diào)度器會根據(jù)需要掛起和恢復(fù)Goroutine，以實現(xiàn)高效的并發(fā)調(diào)度。調(diào)度器可能會在以下情況下掛起Goroutine：

• 時間片用完：Go調(diào)度器使用協(xié)作式調(diào)度，當一個Goroutine的時間片用完時，調(diào)度器會掛起該Goroutine，并調(diào)度其他Goroutine執(zhí)行。
• 主動讓出：Goroutine可以通過調(diào)用runtime.Gosched()主動讓出CPU，調(diào)度器會掛起該Goroutine，并調(diào)度其他Goroutine執(zhí)行。

4. Goroutine的創(chuàng)建和銷毀

• 創(chuàng)建：當一個新的Goroutine被創(chuàng)建時，它會被掛起，直到調(diào)度器將其調(diào)度執(zhí)行。
• 銷毀：當一個Goroutine執(zhí)行完畢或被顯式終止時，它會被掛起并從調(diào)度器中移除。

Goroutine的棧管理

Goroutine的?？臻g是動態(tài)分配的，可以根據(jù)需要自動擴展。Go運行時使用分段棧（segmented stack）或連續(xù)棧（continuous stack）來管理Goroutine的棧空間：

• 分段棧：在早期版本的Go中，Goroutine使用分段棧。每個Goroutine的棧由多個小段組成，當棧空間不足時，Go運行時會分配新的棧段并鏈接到現(xiàn)有的棧段上。
• 連續(xù)棧：在Go 1.3及以后的版本中，Goroutine使用連續(xù)棧。每個Goroutine的棧是一個連續(xù)的內(nèi)存塊，當?？臻g不足時，Go運行時會分配一個更大的棧，并將現(xiàn)有的棧內(nèi)容復(fù)制到新的棧中。