Golang Goroutine的使用方法有哪些

這篇文章將為大家詳細講解有關Golang Goroutine的使用方法有哪些，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

什么是 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的使用方法有哪些就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。