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執行一次垃圾回收。(若是你迫切的但願作一次垃圾回收，能夠調用此函數)

---

其它的你們自行去文檔查看吧~

李培冠博客

歡迎訪問個人我的網站：

李培冠博客：lpgit.com