Golang 中的併發限制與超時控制

前言

上回在 用 Go 寫一個輕量級的 ssh 批量操做工具 裏說起過，咱們作 Golang 併發的時候要對併發進行限制，對 goroutine 的執行要有超時控制。那會沒有細說，這裏展開討論一下。

如下示例代碼所有能夠直接在 The Go Playground 上運行測試：

併發

咱們先來跑一個簡單的併發看看

package main

import (
    "fmt"
    "time"
)

func run(task_id, sleeptime int, ch chan string) {

    time.Sleep(time.Duration(sleeptime) * time.Second)
    ch <- fmt.Sprintf("task id %d , sleep %d second", task_id, sleeptime)
    return
}

func main() {
    input := []int{3, 2, 1}
    ch := make(chan string)
    startTime := time.Now()
    fmt.Println("Multirun start")
    for i, sleeptime := range input {
        go run(i, sleeptime, ch)
    }

    for range input {
        fmt.Println(<-ch)
    }

    endTime := time.Now()
    fmt.Printf("Multissh finished. Process time %s. Number of tasks is %d", endTime.Sub(startTime), len(input))
}

函數 run() 接受輸入的參數，sleep 若干秒。而後經過 go 關鍵字併發執行，經過 channel 返回結果。

channel 顧名思義，他就是 goroutine 之間通訊的「管道"。管道中的數據流通，其實是 goroutine 之間的一種內存共享。咱們經過他能夠在 goroutine 之間交互數據。

ch <- xxx // 向 channel 寫入數據
<- ch // 從 channel 中讀取數據

channel 分爲無緩衝(unbuffered)和緩衝(buffered)兩種。例如剛纔咱們經過以下方式建立了一個無緩衝的 channel。

ch := make(chan string)

channel 的緩衝，咱們一會再說，先看看剛纔看看執行的結果。

Multirun start
task id 2 , sleep 1 second
task id 1 , sleep 2 second
task id 0 , sleep 3 second
Multissh finished. Process time 3s. Number of tasks is 3
Program exited.

三個 goroutine `分別 sleep 了 3，2，1秒。但總耗時只有 3 秒。因此併發生效了，go 的併發就是這麼簡單。

按序返回

剛纔的示例中，我執行任務的順序是 0，1，2。可是從 channel 中返回的順序倒是 2，1，0。這很好理解，由於 task 2 執行的最快嘛，因此先返回了進入了 channel，task 1 次之，task 0 最慢。

若是咱們但願按照任務執行的順序依次返回數據呢？能夠經過一個 channel 數組（好吧，應該叫切片）來作，好比這樣

package main

import (
    "fmt"
    "time"
)

func run(task_id, sleeptime int, ch chan string) {

    time.Sleep(time.Duration(sleeptime) * time.Second)
    ch <- fmt.Sprintf("task id %d , sleep %d second", task_id, sleeptime)
    return
}

func main() {
    input := []int{3, 2, 1}
    chs := make([]chan string, len(input))
    startTime := time.Now()
    fmt.Println("Multirun start")
    for i, sleeptime := range input {
        chs[i] = make(chan string)
        go run(i, sleeptime, chs[i])
    }

    for _, ch := range chs {
        fmt.Println(<-ch)
    }

    endTime := time.Now()
    fmt.Printf("Multissh finished. Process time %s. Number of tasks is %d", endTime.Sub(startTime), len(input))
}

運行結果，如今輸出的次序和輸入的次序一致了。

Multirun start
task id 0 , sleep 3 second
task id 1 , sleep 2 second
task id 2 , sleep 1 second
Multissh finished. Process time 3s. Number of tasks is 3
Program exited.

超時控制

剛纔的例子裏咱們沒有考慮超時。然而若是某個 goroutine 運行時間太長了，那很確定會拖累主 goroutine 被阻塞住，整個程序就掛起在那兒了。所以咱們須要有超時的控制。

一般咱們能夠經過select + time.After 來進行超時檢查，例如這樣，咱們增長一個函數 Run() ，在 Run() 中執行 go run() 。並經過 select + time.After 進行超時判斷。

package main

import (
    "fmt"
    "time"
)

func Run(task_id, sleeptime, timeout int, ch chan string) {
    ch_run := make(chan string)
    go run(task_id, sleeptime, ch_run)
    select {
    case re := <-ch_run:
        ch <- re
    case <-time.After(time.Duration(timeout) * time.Second):
        re := fmt.Sprintf("task id %d , timeout", task_id)
        ch <- re
    }
}

func run(task_id, sleeptime int, ch chan string) {

    time.Sleep(time.Duration(sleeptime) * time.Second)
    ch <- fmt.Sprintf("task id %d , sleep %d second", task_id, sleeptime)
    return
}

func main() {
    input := []int{3, 2, 1}
    timeout := 2
    chs := make([]chan string, len(input))
    startTime := time.Now()
    fmt.Println("Multirun start")
    for i, sleeptime := range input {
        chs[i] = make(chan string)
        go Run(i, sleeptime, timeout, chs[i])
    }

    for _, ch := range chs {
        fmt.Println(<-ch)
    }
    endTime := time.Now()
    fmt.Printf("Multissh finished. Process time %s. Number of task is %d", endTime.Sub(startTime), len(input))
}

運行結果，task 0 和 task 1 已然超時

Multirun start
task id 0 , timeout
task id 1 , timeout
tasi id 2 , sleep 1 second
Multissh finished. Process time 2s. Number of task is 3
Program exited.

併發限制

若是任務數量太多，不加以限制的併發開啓 goroutine 的話，可能會過多的佔用資源，服務器可能會爆炸。因此實際環境中併發限制也是必定要作的。

一種常見的作法就是利用 channel 的緩衝機制——開始的時候咱們提到過的那個。

咱們分別建立一個帶緩衝和不帶緩衝的 channel 看看

ch := make(chan string) // 這是一個無緩衝的 channel，或者說緩衝區長度是 0
ch := make(chan string, 1) // 這是一個帶緩衝的 channel, 緩衝區長度是 1

這二者的區別在於，若是 channel 沒有緩衝，或者緩衝區滿了。goroutine 會自動阻塞，直到 channel 裏的數據被讀走爲止。舉個例子

package main

import (
    "fmt"
)

func main() {
    ch := make(chan string)
    ch <- "123"
    fmt.Println(<-ch)
}

這段代碼執行將報錯

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
    /tmp/sandbox531498664/main.go:9 +0x60

Program exited.

這是由於咱們建立的 ch 是一個無緩衝的 channel。所以在執行到 ch<-"123",這個 goroutine 就阻塞了，後面的 fmt.Println(<-ch) 沒有辦法獲得執行。因此將會報 deadlock錯誤。

若是咱們改爲這樣，程序就能夠執行

package main

import (
    "fmt"
)

func main() {
    ch := make(chan string, 1)
    ch <- "123"
    fmt.Println(<-ch)
}

執行

123

Program exited.

若是咱們改爲這樣

package main

import (
    "fmt"
)

func main() {
    ch := make(chan string, 1)
    ch <- "123"
    ch <- "123"
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

儘管讀取了兩次 channel，可是程序仍是會死鎖，由於緩衝區滿了，goroutine 阻塞掛起。第二個 ch<- "123" 是沒有辦法寫入的。

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
    /tmp/sandbox642690323/main.go:10 +0x80

Program exited.

所以，利用 channel 的緩衝設定，咱們就能夠來實現併發的限制。咱們只要在執行併發的同時，往一個帶有緩衝的 channel 裏寫入點東西（隨便寫啥，內容不重要）。讓併發的 goroutine 在執行完成後把這個 channel 裏的東西給讀走。這樣整個併發的數量就講控制在這個 channel 的緩衝區大小上。

好比咱們能夠用一個 bool 類型的帶緩衝 channel 做爲併發限制的計數器。

chLimit := make(chan bool, 1)

而後在併發執行的地方，每建立一個新的 goroutine，都往 chLimit 裏塞個東西。

for i, sleeptime := range input {
        chs[i] = make(chan string, 1)
        chLimit <- true
        go limitFunc(chLimit, chs[i], i, sleeptime, timeout)
    }

這裏經過 go 關鍵字併發執行的是新構造的函數。他在執行完原來的 Run() 後，會把 chLimit 的緩衝區裏給消費掉一個。

limitFunc := func(chLimit chan bool, ch chan string, task_id, sleeptime, timeout int) {
        Run(task_id, sleeptime, timeout, ch)
        <-chLimit
    }

這樣一來，當建立的 goroutine 數量到達 chLimit 的緩衝區上限後。主 goroutine 就掛起阻塞了，直到這些 goroutine 執行完畢，消費掉了 chLimit 緩衝區中的數據，程序纔會繼續建立新的 goroutine。咱們併發數量限制的目的也就達到了。

如下是完整代碼

package main

import (
    "fmt"
    "time"
)

func Run(task_id, sleeptime, timeout int, ch chan string) {
    ch_run := make(chan string)
    go run(task_id, sleeptime, ch_run)
    select {
    case re := <-ch_run:
        ch <- re
    case <-time.After(time.Duration(timeout) * time.Second):
        re := fmt.Sprintf("task id %d , timeout", task_id)
        ch <- re
    }
}

func run(task_id, sleeptime int, ch chan string) {

    time.Sleep(time.Duration(sleeptime) * time.Second)
    ch <- fmt.Sprintf("task id %d , sleep %d second", task_id, sleeptime)
    return
}

func main() {
    input := []int{3, 2, 1}
    timeout := 2
    chLimit := make(chan bool, 1)
    chs := make([]chan string, len(input))
    limitFunc := func(chLimit chan bool, ch chan string, task_id, sleeptime, timeout int) {
        Run(task_id, sleeptime, timeout, ch)
        <-chLimit
    }
    startTime := time.Now()
    fmt.Println("Multirun start")
    for i, sleeptime := range input {
        chs[i] = make(chan string, 1)
        chLimit <- true
        go limitFunc(chLimit, chs[i], i, sleeptime, timeout)
    }

    for _, ch := range chs {
        fmt.Println(<-ch)
    }
    endTime := time.Now()
    fmt.Printf("Multissh finished. Process time %s. Number of task is %d", endTime.Sub(startTime), len(input))
}

運行結果

Multirun start
task id 0 , timeout
task id 1 , timeout
task id 2 , sleep 1 second
Multissh finished. Process time 5s. Number of task is 3
Program exited.

chLimit 的緩衝是 1。task 0 和 task 1 耗時 2 秒超時。task 2 耗時 1 秒。總耗時 5 秒。併發限制生效了。

若是咱們修改併發限制爲 2

chLimit := make(chan bool, 2)

運行結果

Multirun start
task id 0 , timeout
task id 1 , timeout
task id 2 , sleep 1 second
Multissh finished. Process time 3s. Number of task is 3
Program exited.

task 0 , task 1 併發執行，耗時 2秒。task 2 耗時 1秒。總耗時 3 秒。符合預期。

有沒有注意到代碼裏有個地方和以前不一樣。這裏，用了一個帶緩衝的 channel

chs[i] = make(chan string, 1)

還記得上面的例子麼。若是 channel 不帶緩衝，那麼直到他被消費掉以前，這個 goroutine 都會被阻塞掛起。
然而若是這裏的併發限制，也就是 chLimit 生效阻塞了主 goroutine，那麼後面消費這些數據的代碼並不會執行到。。。因而就 deadlock 拉！

for _, ch := range chs {
        fmt.Println(<-ch)
    }

因此給他一個緩衝就行了。

參考文獻

從Deadlock報錯理解Go channel機制（一）
golang-what-is-channel-buffer-size
golang-using-timeouts-with-channels

以上

轉載受權

CC BY-SA