Go 併發的一些總結

時間 2019-11-16

標籤併發一些總結简体版

原文原文鏈接

GO併發

goroutine

goroutine是Go並行設計的核心。goroutine說到底其實就是協程，可是它比線程更小，十幾個goroutine可能體如今底層就是五六個線程，Go語言內部幫你實現了這些goroutine之間的內存共享。執行goroutine只需極少的棧內存(大概是4~5KB)，固然會根據相應的數據伸縮。也正由於如此，可同時運行成千上萬個併發任務。goroutine比thread更易用、更高效、更輕便。程序員

Go routine並不會運行得比線程更快更快，它只是增長了更多的併發性。當一個goroutine被阻塞（好比等待IO），golang的scheduler會調度其它能夠執行的goroutine運行。與線程相比，它有如下幾個優勢：golang

內存消耗更少：shell
- Goroutine所須要的內存一般只有2kb，而線程則須要1Mb（500倍）。
建立與銷燬的開銷更小編程
- 因爲線程建立時須要向操做系統申請資源，而且在銷燬時將資源歸還，所以它的建立和銷燬的開銷比較大。相比之下，goroutine的建立和銷燬是由go語言在運行時本身管理的，所以開銷更低。
切換開銷更小緩存
- 這是goroutine於線程的主要區別，也是golang可以實現高併發的主要緣由。線程的調度方式是搶佔式的，若是一個線程的執行時間超過了分配給它的時間片，就會被其它可執行的線程搶佔。在線程切換的過程當中須要保存/恢復全部的寄存器信息，好比16個通用寄存器，PC（Program Counter），SP（Stack Pointer），段寄存器等等。

goroutine是經過Go的runtime管理的一個線程管理器。goroutine經過go關鍵字實現了，就是一個普通的函數。安全

go hello(a, b, c)

經過關鍵字go啓動goroutine。網絡

package main

import (
    "fmt"
    "runtime"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        runtime.Gosched()
        fmt.Println(s)
    }
}

func main() {
    go say("world") //開一個新的Goroutines執行
    say("hello") //當前Goroutines執行
}

// 以上程序執行後將輸出：
// hello
// world
// hello
// world
// hello
// world
// hello
// world
// hello

能夠看到go關鍵字很方便的就實現了併發編程。
上面的多個goroutine運行在同一個進程裏面，共享內存數據，不過設計上咱們要遵循：不要經過共享來通訊，而要經過通訊來共享。數據結構

runtime.Gosched()表示讓CPU把時間片讓給別人,下次某個時候繼續恢復執行該goroutine。
默認狀況下，在Go 1.5將標識併發系統線程個數的runtime.GOMAXPROCS的初始值由1改成了運行環境的CPU核數。併發

但在Go 1.5之前調度器僅使用單線程，也就是說只實現了併發。想要發揮多核處理器的並行，須要在咱們的程序中顯式調用 runtime.GOMAXPROCS(n) 告訴調度器同時使用多個線程。GOMAXPROCS 設置了同時運行邏輯代碼的系統線程的最大數量，並返回以前的設置。若是n < 1，不會改變當前設置。異步

正如前面提到的，goroutine的調度方式是協同式的。在協同式調度中，沒有時間片的概念。爲了並行執行goroutine，調度器會在如下幾個時間點對其進行切換：

Channel接受或者發送會形成阻塞的消息
當一個新的goroutine被建立時
能夠形成阻塞的系統調用，如文件和網絡操做

channels

不一樣goroutine之間通信

全局變量的互斥鎖
使用管道channel來解決

channle本質就是一個數據結構-隊列
數據是先進先出【FIFO : first in first out】
線程安全，多goroutine訪問時，不須要加鎖，就是說channel自己就是線程安全的
channel有類型的，一個string的channel只能存放string類型數據。

Go 語言中使用了CSP模型來進行線程通訊，準確說，是輕量級線程goroutine之間的通訊。CSP模型和Actor模型相似，也是由獨立的，併發執行的實體所構成，實體之間也是經過發送消息進行通訊的。Actor模型和CSP模型區別Actor之間直接通信，而CSP是經過Channel通信，在耦合度上二者是有區別的，後者更加鬆耦合。主要的區別在於：CSP模型中消息的發送者和接收者之間經過Channel鬆耦合，發送者不知道本身消息被哪一個接收者消費了，接收者也不知道是哪一個發送者發送的消息。在Actor模型中，因爲Actor能夠根據本身的狀態選擇處理哪一個傳入消息，自主性可控性更好些。在Go語言中爲了避免堵塞進程，程序員必須檢查不一樣的傳入消息，以便預見確保正確的順序。CSP好處是Channel不須要緩衝消息，而Actor理論上須要一個無限大小的郵箱做爲消息緩衝。CSP模型的消息發送方只能在接收方準備好接收消息時才能發送消息。相反，Actor模型中的消息傳遞是異步的，即消息的發送和接收無需在同一時間進行，發送方能夠在接收方準備好接收消息前將消息發送出去。

goroutine運行在相同的地址空間，所以訪問共享內存必須作好同步。Go提供了一個很好的goroutine之間進行數據的通訊的機制channel。channel能夠與Unix shell 中的雙向管道作類比：能夠經過它發送或者接收值。這些值只能是特定的類型：channel類型。定義一個channel時，也須要定義發送到channel的值的類型。注意，必須使用make 建立channel：

ci := make(chan int)
cs := make(chan string)
cf := make(chan interface{})

channel經過操做符<-來接收和發送數據

ch <- v    // 發送v到channel ch.
v := <-ch  // 從ch中接收數據，並賦值給v

把這些應用到咱們的例子中來：

package main

import "fmt"

func sum(a []int, c chan int) {
    total := 0
    for _, v := range a {
        total += v
    }
    c <- total  // send total to c
}

func main() {
    a := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(a[:len(a)/2], c)
    go sum(a[len(a)/2:], c)
    x, y := <-c, <-c  // receive from c

    fmt.Println(x, y, x + y)
}

默認狀況下，channel接收和發送數據都是阻塞的，除非另外一端已經準備好，這樣就使得Goroutines同步變的更加的簡單，而不須要顯式的lock。所謂阻塞，也就是若是讀取（value := <-ch）它將會被阻塞，直到有數據接收。其次，任何發送（ch<-5）將會被阻塞，直到數據被讀出。無緩衝channel是在多個goroutine之間同步很棒的工具。

Buffered Channels

上面咱們介紹了默認的非緩存類型的channel，不過Go也容許指定channel的緩衝大小，很簡單，就是channel能夠存儲多少元素。ch:= make(chan bool, 4)，建立了能夠存儲4個元素的bool 型channel。在這個channel 中，前4個元素能夠無阻塞的寫入。當寫入第5個元素時，代碼將會阻塞，直到其餘goroutine從channel 中讀取一些元素，騰出空間。

ch := make(chan type, value)

當 value = 0 時，channel 是無緩衝阻塞讀寫的，當value > 0 時，channel 有緩衝、是非阻塞的，直到寫滿 value 個元素才阻塞寫入。

看一下下面這個例子

package main

import "fmt"

func main() {
    c := make(chan int, 2)//修改2爲1就報錯，修改2爲3能夠正常運行
    c <- 1
    c <- 2
    fmt.Println(<-c)
    fmt.Println(<-c)
}
        //修改成1報以下的錯誤:
        //fatal error: all goroutines are asleep - deadlock!

總結：channel使用的注意事項

channel中只能存放指定的數據類型
channle的數據放滿後，就不能再放入了
若是從channel取出數據後，能夠繼續放入
在沒有使用協程的狀況下，若是channel數據取完了，再取，就會報dead lock

Range和Close

上面這個例子中，咱們須要讀取兩次c，這樣不是很方便，Go考慮到了這一點，因此也能夠經過range，像操做slice或者map同樣操做緩存類型的channel，請看下面的例子

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    x, y := 1, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x + y
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.Println(i)
    }
}

for i := range c可以不斷的讀取channel裏面的數據，直到該channel被顯式的關閉。上面代碼咱們看到能夠顯式的關閉channel，生產者經過內置函數close關閉channel。關閉channel以後就沒法再發送任何數據了，在消費方能夠經過語法v, ok := <-ch測試channel是否被關閉。若是ok返回false，那麼說明channel已經沒有任何數據而且已經被關閉。

記住應該在生產者的地方關閉channel，而不是消費的地方去關閉它，這樣容易引發panic
另外記住一點的就是channel不像文件之類的，不須要常常去關閉，只有當你確實沒有任何發送數據了，或者你想顯式的結束range循環之類的

Select

上面介紹的都是隻有一個channel的狀況，那麼若是存在多個channel的時候，該如何操做呢，Go裏面提供了一個關鍵字select，經過select能夠監聽channel上的數據流動。

select默認是阻塞的，只有當監聽的channel中有發送或接收能夠進行時纔會運行，當多個channel都準備好的時候，select是隨機的選擇一個執行的。

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 1, 1
    for {
        select {
        case c <- x:
            x, y = y, x + y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

在select裏面還有default語法，select其實就是相似switch的功能，default就是當監聽的channel都沒有準備好的時候，默認執行的（select再也不阻塞等待channel）。

select {
case i := <-c:
    // use i
default:
    // 當c阻塞的時候執行這裏
}

超時

有時候會出現goroutine阻塞的狀況，那麼如何避免整個程序進入阻塞的狀況呢？咱們能夠利用select來設置超時，經過以下的方式實現：

func main() {
    c := make(chan int)
    o := make(chan bool)
    go func() {
        for {
            select {
                case v := <- c:
                    println(v)
                case <- time.After(5 * time.Second):
                    println("timeout")
                    o <- true
                    break
            }
        }
    }()
    <- o
}