goroutine 是 Golang的最大賣點之一，它讓并發編程變的十分簡單，僅僅使用 go關鍵字就能快速的創建goroutine。與其他語言設計并發程序相比，這極大的減少了程序員的心智負擔。

goroutine的特點

• 輕量級

goroutine是用戶態"線程"，開銷非常小，最新golang版本默認為goroutine分配的初始棧大小為2k，同時會根據運行狀況動態擴展或收縮。一個有2G內存的機器，理論上可以容納一百萬 goroutine。

• 協作式調度

golang的runtime采用協作式調度，goroutine的運行原則上不能被搶占，除非goroutine主動讓出CPU，否則goroutine會運行到結束，所以context switch 開銷基本可以忽略。

• 高效的線程模型

golang為了充分發揮多核機器的優勢，采用了M:N線程模型，即M個內核線程，每個內核線程可以為N個goroutine提供運行環境，最大限度的發揮了多核機器的能力。

幾個關鍵的數據結構

• g

g代表一個goroutine實例，在golang源碼src/runtime/runtime2.go 中，可以看到g的詳細定義。和普通的線程一樣，g主要包含：可伸縮的運行棧，goroutine切換時的上下文環境（gobuf），程序計數器，基地址，可執行代碼等。

type g struct {
        stack      stack   // offset known to runtime/cgo
        sched     gobuf
        goid        int64
        gopc       uintptr // pc of go statement that created this goroutine
        startpc    uintptr // pc of goroutine function
        ... ...
}

• m

m代表一個內核線程，是goroutine真正的執行環境。一般會有一個內核線程池，當goroutine因為等待網絡數據或者讀取文件等阻塞時，goroutine會綁定在這個m上，等到阻塞操作的完成后重新綁定到一個p上繼續運行。若暫時找不到可用的p，那么這個goroutine會放到全局的 run queue 中。

type m struct {
    g0      *g     // goroutine with scheduling stack
    mstartfn      func()
    curg          *g       // current running goroutine
 .... ..
}

• p

早起版本的golang實現不包含p這一結構，p表示一個邏輯處理器，p的數量一般為機器的CPU核心數，每個p下面掛載有等待被調度的goroutine. 每個 goroutine想要運行需要首先獲得p才能被調度。p數量決定了系統的最大并發度。

type p struct {
    lock mutex

    id          int32
    status      uint32 // one of pidle/prunning/...

    mcache      *mcache
    racectx     uintptr

    // Queue of runnable goroutines. Accessed without lock.
    runqhead uint32
    runqtail uint32
    runq     [256]guintptr

    runnext guintptr

    // Available G's (status == Gdead)
    gfree    *g
    gfreecnt int32

  ... ...
}

g, m, p 的關系如下圖所示

G,M,P關系圖（圖片來自網絡）

上圖左半部分，M₁為空閑線程，M₀線程下面有一個P和它綁定，P下面有一個正在運行的G₀，還有其他等待運行的G。在某個時候，G₀中發生了系統調用，P與M₀解綁，尋找空閑的線程M₁，綁定到上面繼續執行P下的其他G，M₀與G₀陷入系統調用，如上圖右半部分所示。

為何需要搶占式調度

goroutine里面的代碼執行沒有確定的時間，如果一個goroutine長期占有p運行，甚至一個死循環，那么p下面的其他g就無法得到調度，這種情況是我們不希望看到的。幸好，系統監控線程 sysmon可以判斷這種情況，它可以打斷當前goroutine的執行，使P下的其他G得到調度。

sysmon主要完成如下工作：

• 釋放閑置超過5分鐘的span物理內存；
• 如果超過2分鐘沒有垃圾回收，強制執行；
• 將長時間未處理的netpoll結果添加到任務隊列；
• 向長時間運行的G任務發出搶占調度；
• 收回因syscall長時間阻塞的P；

因此，我們不應該在goroutine里面設計長時間運行的任務。這種搶占機制在一定程度上保證了同一P下G的公平調度。

work stealing 算法

當p下面沒有可供調度的goroutine時，他會從global run queue或者其他p下的goroutine中“偷” 一部分goroutine來運行，這樣最大限度的利用多核。這在一定程度上保證了在各個CPU核上的負載均衡。

如何處理阻塞的系統調用

對于普通的文件IO操作一旦阻塞，那么m就會進入sleep狀態，IO完成之后才會被喚醒。這種情況下，p將與m分離，選擇其他空閑的m繼續執行。如果沒有空閑的m，那么就會新創建一個m。可想而知，如果有大量的這樣的文件IO操作，大量的m將會被創建出來，這時候操作系統對m的調度開銷就不能忽視了。

針對網絡IO，golang使用netpoller做出了特別的優化，這樣goroutine里面發起網絡IO也不會導致m被阻塞，從而不會引起創建大量的內核線程m。

goroutine的調度順序

調度器對goroutine的調度是隨機的，沒有固定的順序，即使設置 runtime.GOMAXPROCS(1)。看一個實例程序。

package main

import (
    "fmt"
    "time"
    "runtime"
)

func foo(n int) {
    fmt.Println(n)
}

func main() {
    runtime.GOMAXPROCS(1)
    for i := 0; i < 10000; i++ {
        go foo(i)
    }
    
    time.Sleep(2 * time.Second)
}

上述代碼不會從 0 開始順序打印到 10000。即使設置 runtime.GOMAXPROCS(1)，我們也看到 goroutine的調度是隨機的。

goroutine發生調度的時機

goroutine在獲得m時一般不能一直運行到完畢，它們往往可能要等待其他資源才能執行完成，比如說一個http請求收到服務器響應這個goroutine才算完成了他的任務。在等待服務器響應的這一段時間它不會占用CPU時間 ，調度器會調度其他goroutine繼續執行。goroutine遇到下面的情況下可能會產生重新調度

• 阻塞 I/O
• select操作
• 阻塞在channel
• 等待鎖
• 主動調用 runtime.Gosched()

參考鏈接

• 聊一聊goroutine stack
• A complete journey with Goroutines
  
• go-internals
• http://morsmachine.dk/go-scheduler
• https://news.ycombinator.com/item?id=12459841
• https://golang.org/src/runtime/runtime2.go
• https://www.zhihu.com/question/20862617
• goroutine與調度器
• golang密集場景下協程調度饑餓問題
• Handling 1 Million Requests per Minute with Go
• LearnConcurrency
• Go's work-stealing scheduler
• Golang源碼探索(二) 協程的實現原理
• 也談goroutine調度器
• Goroutine淺析
• Twelve Go Best Practices
• golang netpoller