什么是 Goroutine

goroutine 是 Go 并行設計的核心。goroutine 說到底其實就是協程，它比線程更小，十幾個 goroutine 可能體現在底層就是五六個線程，Go 語言內部幫你實現了這些 goroutine 之間的內存共享。

執行 goroutine 只需極少的棧內存(大概是4~5KB)，當然會根據相應的數據伸縮。也正因為如此，可同時運行成千上萬個并發任務。goroutine 比 thread 更易用、更高效、更輕便。

一般情況下，一個普通計算機跑幾十個線程就有點負載過大了，但是同樣的機器卻可以輕松地讓成百上千個 goroutine 進行資源競爭。

Goroutine 的創建

只需在函數調⽤語句前添加 go 關鍵字，就可創建并發執⾏單元。

開發⼈員無需了解任何執⾏細節，調度器會自動將其安排到合適的系統線程上執行。

在并發編程中，我們通常想將一個過程切分成幾塊，然后讓每個 goroutine 各自負責一塊工作，當一個程序啟動時，主函數在一個單獨的 goroutine 中運行，我們叫它 main goroutine。新的 goroutine 會用 go 語句來創建。而 go 語言的并發設計，讓我們很輕松就可以達成這一目的。

例如：

package main

import (
 "fmt"
 "time"
)

func foo() {
 i := 0
 for true {
 i++
 fmt.Println("new goroutine: i = ", i)
 time.Sleep(time.Second)
 }
}

func main() {
 // 創建一個 goroutine, 啟動另外一個任務
 go foo()

 i := 0
 for true {
 i++
 fmt.Println("main goroutine: i = ", i)
 time.Sleep(time.Second)
 }
}

結果：

main goroutine: i =  1
new goroutine: i =  1
new goroutine: i =  2
main goroutine: i =  2
main goroutine: i =  3
new goroutine: i =  3
...

Goroutine 特性

主go程 退出后，其它的 子go程 也會自動退出：

package main

import (
 "fmt"
 "time"
)

func foo() {
 i := 0
 for true {
 i++
 fmt.Println("new goroutine: i = ", i)
 time.Sleep(time.Second)
 }
}

func main() {
 // 創建一個 goroutine, 啟動另外一個任務
 go foo()

 time.Sleep(time.Second * 3)

 fmt.Println("main goroutine exit")
}

運行結果：

new goroutine: i =  1
new goroutine: i =  2
new goroutine: i =  3
main goroutine exit

runtime 包

Gosched

runtime.Gosched() 用于出讓當前 go程 所占用的 CPU 時間片，讓出當前 goroutine 的執行權限，調度器安排其他等待的任務運行，并在下次再獲得 cpu 時間輪片的時候，從該出讓 cpu 的位置恢復執行。

有點像跑接力賽，A 跑了一會碰到代碼 runtime.Gosched() 就把接力棒交給 B 了，A 歇著了，B 繼續跑。

例如：

package main

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

func main() {
 // 創建一個 goroutine
 go func(s string) {
 for i := 0; i  2; i++ {
  fmt.Println(s)
 }
 }("world")

 for i := 0; i  2; i++ {
 runtime.Gosched()
 fmt.Println("hello")
 }
 time.Sleep(time.Second * 3)
}

運行結果：

world
world
hello
hello

如果沒有 runtime.Gosched() 則運行結果如下：

hello
hello
world
world

注意： runtime.Gosched() 只是出讓一次機會，看下面的代碼，注意運行結果：

package main

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

func main() {
 // 創建一個 goroutine
 go func(s string) {
 for i := 0; i  2; i++ {
  fmt.Println(s)
  time.Sleep(time.Second)
 }
 }("world")

 for i := 0; i  2; i++ {
 runtime.Gosched()
 fmt.Println("hello")
 }
}

運行結果：

world
hello
hello

為什么 world 只有一次呢？因為之前我們說過，主 goroutine 退出后，其它的工作 goroutine 也會自動退出。

Goexit

調用 runtime.Goexit() 將立即終止當前 goroutine 執⾏，調度器確保所有已注冊 defer 延遲調用被執行。

注意與 return 的區別，return 是返回當前函數調用給調用者。

例如：

package main

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

func main() {
 go func() {
 defer fmt.Println("A.defer")
 func() {
  defer fmt.Println("B.defer")
  runtime.Goexit() // 終止當前 goroutine
  fmt.Println("B") // 不會執行
 }()
 fmt.Println("A") // 不會執行
 }() // 不要忘記 ()

 time.Sleep(time.Second * 3)
}

運行結果：

B.defer
A.defer

GOMAXPROCS

調用 runtime.GOMAXPROCS() 用來設置可以并行計算的 CPU 核數的最大值，并返回 上一次（沒有則是電腦默認的） 設置的值。

package main

import (
 "fmt"
 "runtime"
)

func main() {
 runtime.GOMAXPROCS(1) // 將 cpu 設置為單核

 for true {
 go fmt.Print(0) // 子 go 程
 fmt.Print(1) // 主 go 程
 }
}

運行結果：

111111 ... 1000000 ... 0111 ...

在執行 runtime.GOMAXPROCS(1) 時，最多同時只能有一個 goroutine 被執行。所以會打印很多 1。過了一段時間后，GO 調度器會將其置為休眠，并喚醒另一個 goroutine，這時候就開始打印很多 0 了，在打印的時候，goroutine 是被調度到操作系統線程上的。

package main

import (
 "fmt"
 "runtime"
)

func main() {
 runtime.GOMAXPROCS(2)

 for true {
 go fmt.Print(0)
 fmt.Print(1)
 }
}

運行結果：

111111111111111000000000000000111111111111111110000000000000000011111111100000...

在執行 runtime.GOMAXPROCS(2) 時， 我們使用了兩個 CPU，所以兩個 goroutine 可以一起被執行，以同樣的頻率交替打印 0 和 1。

runtime 包中的其它函數

中文文檔在這里：https://studygolang.com/pkgdoc

這里就簡單列舉一下一些函數以及功能。

func GOROOT() string

GOROOT 返回 Go 的根目錄。如果存在 GOROOT 環境變量，返回該變量的值；否則，返回創建 Go 時的根目錄。

func Version() string

返回 Go 的版本字符串。它要么是遞交的 hash 和創建時的日期；要么是發行標簽如 "go1.3"。

func NumCPU() int

NumCPU返回本地機器的邏輯CPU個數（真 · 八核）。

func GC()

GC執行一次垃圾回收。(如果你迫切的希望做一次垃圾回收，可以調用此函數)

到此這篇關于Golang Goroutine的使用的文章就介紹到這了,更多相關Golang Goroutine內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持腳本之家！