1. 程式人生 > >golang語言併發與並行——goroutine和channel的詳細理解

golang語言併發與並行——goroutine和channel的詳細理解

轉載自:

http://blog.csdn.net/skh2015java/article/details/60330785

http://blog.csdn.net/skh2015java/article/details/60330875

http://blog.csdn.net/skh2015java/article/details/60330975

如果不是我對真正並行的執行緒的追求,就不會認識到Go有多麼的迷人。

Go語言從語言層面上就支援了併發,這與其他語言大不一樣,不像以前我們要用Thread庫 來新建執行緒,還要用執行緒安全的佇列庫來共享資料。

以下是我入門的學習筆記。

Go語言的goroutines、通道和死鎖

goroutine

Go語言中有個概念叫做goroutine, 這類似我們熟知的執行緒,但是更輕。

以下的程式,我們序列地去執行兩次loop函式:

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
}


func main() {
    loop()
    loop()
}

毫無疑問,輸出會是這樣的:

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

下面我們把一個loop放在一個goroutine裡跑,我們可以使用關鍵字go

來定義並啟動一個goroutine:

func main() {
    go loop() // 啟動一個goroutine
    loop()
}

這次的輸出變成了:

0 1 2 3 4 5 6 7 8 9

可是為什麼只輸出了一趟呢?明明我們主線跑了一趟,也開了一個goroutine來跑一趟啊。

原來,在goroutine還沒來得及跑loop的時候,主函式已經退出了。

main函式退出地太快了,我們要想辦法阻止它過早地退出,一個辦法是讓main等待一下:

func main() {
    go loop()
    loop()
    time
.Sleep(time.Second) // 停頓一秒 }

這次確實輸出了兩趟,目的達到了。

可是採用等待的辦法並不好,如果goroutine在結束的時候,告訴下主線說“Hey, 我要跑完了!”就好了, 即所謂阻塞主線的辦法,回憶下我們Python裡面等待所有執行緒執行完畢的寫法:

for thread in threads:
    thread.join()

是的,我們也需要一個類似join的東西來阻塞住主線。那就是通道

通道

通道是什麼?簡單說,是goroutine之間互相通訊的東西。類似我們Unix上的管道(可以在程序間傳遞訊息), 用來goroutine之間發訊息和接收訊息。其實,就是在做goroutine之間的記憶體共享。

使用make來建立一個通道:

var channel chan int = make(chan int)
// 或
channel := make(chan int)

那如何向通道存訊息和取訊息呢? 一個例子:

func main() {
    var messages chan string = make(chan string)
    go func(message string) {
        messages <- message // 存訊息
    }("Ping!")

    fmt.Println(<-messages) // 取訊息
}

預設的,通道的存訊息和取訊息都是阻塞的 (叫做無緩衝的通道,不過緩衝這個概念稍後瞭解,先說阻塞的問題)。

也就是說, 無緩衝的通道在取訊息和存訊息的時候都會掛起當前的goroutine,除非另一端已經準備好。

比如以下的main函式和foo函式:

var ch chan int = make(chan int)

func foo() {
    ch <- 0  // 向ch中加資料,如果沒有其他goroutine來取走這個資料,那麼掛起foo, 直到main函式把0這個資料拿走
}

func main() {
    go foo()
    <- ch // 從ch取資料,如果ch中還沒放資料,那就掛起main線,直到foo函式中放資料為止
}

那既然通道可以阻塞當前的goroutine, 那麼回到上一部分「goroutine」所遇到的問題「如何讓goroutine告訴主線我執行完畢了」 的問題來, 使用一個通道來告訴主線即可:

var complete chan int = make(chan int)

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }

    complete <- 0 // 執行完畢了,發個訊息
}


func main() {
    go loop()
    <- complete // 直到執行緒跑完, 取到訊息. main在此阻塞住
}

如果不用通道來阻塞主線的話,主線就會過早跑完,loop線都沒有機會執行

其實,無緩衝的通道永遠不會儲存資料,只負責資料的流通,為什麼這麼講呢?

  • 從無緩衝通道取資料,必須要有資料流進來才可以,否則當前線阻塞

  • 資料流入無緩衝通道, 如果沒有其他goroutine來拿走這個資料,那麼當前線阻塞

所以,你可以測試下,無論如何,我們測試到的無緩衝通道的大小都是0 (len(channel))

如果通道正有資料在流動,我們還要加入資料,或者通道乾澀,我們一直向無資料流入的空通道取資料呢? 就會引起死鎖

死鎖

一個死鎖的例子:

func main() {
    ch := make(chan int)
    <- ch // 阻塞main goroutine, 通道c被鎖
}

執行這個程式你會看到Go報這樣的錯誤:

fatal error: all goroutines are asleep - deadlock!

何謂死鎖? 作業系統有講過的,所有的執行緒或程序都在等待資源的釋放。如上的程式中, 只有一個goroutine, 所以當你向裡面加資料或者存資料的話,都會鎖死通道, 並且阻塞當前 goroutine, 也就是所有的goroutine(其實就main線一個)都在等待通道的開放(沒人拿走資料通道是不會開放的),也就是死鎖咯。

我發現死鎖是一個很有意思的話題,這裡有幾個死鎖的例子:

  1. 只在單一的goroutine裡操作無緩衝通道,一定死鎖。比如你只在main函式裡操作通道:

    func main() {
        ch := make(chan int)
        ch <- 1 // 1流入通道,堵塞當前線, 沒人取走資料通道不會開啟
        fmt.Println("This line code wont run") //在此行執行之前Go就會報死鎖
    }
    
  2. 如下也是一個死鎖的例子:

    var ch1 chan int = make(chan int)
    var ch2 chan int = make(chan int)
    
    func say(s string) {
        fmt.Println(s)
        ch1 <- <- ch2 // ch1 等待 ch2流出的資料
    }
    
    func main() {
        go say("hello")
        <- ch1  // 堵塞主線
    }
    

    其中主線等ch1中的資料流出,ch1等ch2的資料流出,但是ch2等待資料流入,兩個goroutine都在等,也就是死鎖。

  3. 其實,總結來看,為什麼會死鎖?非緩衝通道上如果發生了流入無流出,或者流出無流入,也就導致了死鎖。或者這樣理解 Go啟動的所有goroutine裡的非緩衝通道一定要一個線裡存資料,一個線裡取資料,要成對才行 。所以下面的示例一定死鎖:

    c, quit := make(chan int), make(chan int)
    
    go func() {
       c <- 1  // c通道的資料沒有被其他goroutine讀取走,堵塞當前goroutine
       quit <- 0 // quit始終沒有辦法寫入資料
    }()
    
    <- quit // quit 等待資料的寫
    

    仔細分析的話,是由於:主線等待quit通道的資料流出,quit等待資料寫入,而func被c通道堵塞,所有goroutine都在等,所以死鎖。

    簡單來看的話,一共兩個線,func線中流入c通道的資料並沒有在main線中流出,肯定死鎖。

但是,是否果真 所有不成對向通道存取資料的情況都是死鎖?

如下是個反例:

func main() {
    c := make(chan int)

    go func() {
       c <- 1
    }()
}

程式正常退出了,很簡單,並不是我們那個總結不起作用了,還是因為一個讓人很囧的原因,main又沒等待其它goroutine,自己先跑完了, 所以沒有資料流入c通道,一共執行了一個goroutine, 並且沒有發生阻塞,所以沒有死鎖錯誤。

那麼死鎖的解決辦法呢?

最簡單的,把沒取走的資料取走,沒放入的資料放入, 因為無緩衝通道不能承載資料,那麼就趕緊拿走!

具體來講,就死鎖例子3中的情況,可以這麼避免死鎖:

c, quit := make(chan int), make(chan int)

go func() {
    c <- 1
    quit <- 0
}()

<- c // 取走c的資料!
<-quit

另一個解決辦法是緩衝通道, 即設定c有一個數據的緩衝大小:

c := make(chan int, 1)

這樣的話,c可以快取一個數據。也就是說,放入一個數據,c並不會掛起當前線, 再放一個才會掛起當前線直到第一個資料被其他goroutine取走, 也就是隻阻塞在容量一定的時候,不達容量不阻塞。

這十分類似我們Python中的佇列Queue不是嗎?

無緩衝通道的資料進出順序

我們已經知道,無緩衝通道從不儲存資料,流入的資料必須要流出才可以。

觀察以下的程式:

var ch chan int = make(chan int)

func foo(id int) { //id: 這個routine的標號
    ch <- id
}

func main() {
    // 開啟5個routine
    for i := 0; i < 5; i++ {
        go foo(i)
    }

    // 取出通道中的資料
    for i := 0; i < 5; i++ {
        fmt.Print(<- ch)
    }
}

我們開了5個goroutine,然後又依次取資料。其實整個的執行過程細分的話,5個線的資料 依次流過通道ch, main列印之, 而巨集觀上我們看到的即 無緩衝通道的資料是先到先出,但是 無緩衝通道並不儲存資料,只負責資料的流通

緩衝通道

終於到了這個話題了, 其實快取通道用英文來講更為達意: buffered channel.

緩衝這個詞意思是,緩衝通道不僅可以流通資料,還可以快取資料。它是有容量的,存入一個數據的話 , 可以先放在信道里,不必阻塞當前線而等待該資料取走。

當緩衝通道達到滿的狀態的時候,就會表現出阻塞了,因為這時再也不能承載更多的資料了,「你們必須把 資料拿走,才可以流入資料」。

在宣告一個通道的時候,我們給make以第二個引數來指明它的容量(預設為0,即無緩衝):

var ch chan int = make(chan int, 2) // 寫入2個元素都不會阻塞當前goroutine, 儲存個數達到2的時候會阻塞

如下的例子,緩衝通道ch可以緩衝的流入3個元素:

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
}

如果你再試圖流入一個數據的話,通道ch會阻塞main線, 報死鎖。

也就是說,緩衝通道會在滿容量的時候加鎖。

其實,緩衝通道是先進先出的,我們可以把緩衝通道看作為一個執行緒安全的佇列