詳解Golang 中的并發(fā)限制與超時(shí)控制
前言
上回在 用 Go 寫一個(gè)輕量級(jí)的 ssh 批量操作工具 里提及過(guò)，我們做 Golang 并發(fā)的時(shí)候要對(duì)并發(fā)進(jìn)行限制，對(duì) goroutine 的執(zhí)行要有超時(shí)控制。那會(huì)沒(méi)有細(xì)說(shuō)，這里展開討論一下。
以下示例代碼全部可以直接在 The Go Playground 上運(yùn)行測(cè)試：
并發(fā)
我們先來(lái)跑一個(gè)簡(jiǎn)單的并發(fā)看看
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))
}
函數(shù) run() 接受輸入的參數(shù)，sleep 若干秒。然后通過(guò) go 關(guān)鍵字并發(fā)執(zhí)行，通過(guò) channel 返回結(jié)果。
channel 顧名思義，他就是 goroutine 之間通信的“管道"。管道中的數(shù)據(jù)流通，實(shí)際上是 goroutine 之間的一種內(nèi)存共享。我們通過(guò)他可以在 goroutine 之間交互數(shù)據(jù)。
ch <- xxx // 向 channel 寫入數(shù)據(jù) <- ch // 從 channel 中讀取數(shù)據(jù)
channel 分為無(wú)緩沖(unbuffered)和緩沖(buffered)兩種。例如剛才我們通過(guò)如下方式創(chuàng)建了一個(gè)無(wú)緩沖的 channel。
ch := make(chan string)
channel 的緩沖，我們一會(huì)再說(shuō)，先看看剛才看看執(zhí)行的結(jié)果。
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.
三個(gè) goroutine `分別 sleep 了 3，2，1秒。但總耗時(shí)只有 3 秒。所以并發(fā)生效了，go 的并發(fā)就是這么簡(jiǎn)單。
按序返回
剛才的示例中，我執(zhí)行任務(wù)的順序是 0，1，2。但是從 channel 中返回的順序卻是 2，1，0。這很好理解，因?yàn)?task 2 執(zhí)行的最快嘛，所以先返回了進(jìn)入了 channel，task 1 次之，task 0 最慢。
如果我們希望按照任務(wù)執(zhí)行的順序依次返回?cái)?shù)據(jù)呢？可以通過(guò)一個(gè) channel 數(shù)組（好吧，應(yīng)該叫切片）來(lái)做，比如這樣
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))
}
運(yùn)行結(jié)果，現(xiàn)在輸出的次序和輸入的次序一致了。
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.
超時(shí)控制
剛才的例子里我們沒(méi)有考慮超時(shí)。然而如果某個(gè) goroutine 運(yùn)行時(shí)間太長(zhǎng)了，那很肯定會(huì)拖累主 goroutine 被阻塞住，整個(gè)程序就掛起在那兒了。因此我們需要有超時(shí)的控制。
通常我們可以通過(guò)select + time.After 來(lái)進(jìn)行超時(shí)檢查，例如這樣，我們?cè)黾右粋€(gè)函數(shù) Run() ，在 Run() 中執(zhí)行 go run() 。并通過(guò) select + time.After 進(jìn)行超時(shí)判斷。
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))
}
運(yùn)行結(jié)果，task 0 和 task 1 已然超時(shí)
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.
并發(fā)限制
如果任務(wù)數(shù)量太多，不加以限制的并發(fā)開啟 goroutine 的話，可能會(huì)過(guò)多的占用資源，服務(wù)器可能會(huì)爆炸。所以實(shí)際環(huán)境中并發(fā)限制也是一定要做的。
一種常見的做法就是利用 channel 的緩沖機(jī)制——開始的時(shí)候我們提到過(guò)的那個(gè)。
我們分別創(chuàng)建一個(gè)帶緩沖和不帶緩沖的 channel 看看
ch := make(chan string) // 這是一個(gè)無(wú)緩沖的 channel，或者說(shuō)緩沖區(qū)長(zhǎng)度是 0 ch := make(chan string, 1) // 這是一個(gè)帶緩沖的 channel, 緩沖區(qū)長(zhǎng)度是 1
這兩者的區(qū)別在于，如果 channel 沒(méi)有緩沖，或者緩沖區(qū)滿了。goroutine 會(huì)自動(dòng)阻塞，直到 channel 里的數(shù)據(jù)被讀走為止。舉個(gè)例子
package main
import (
"fmt"
)
func main() {
ch := make(chan string)
ch <- "123"
fmt.Println(<-ch)
}
這段代碼執(zhí)行將報(bào)錯(cuò)
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox531498664/main.go:9 +0x60Program exited.
這是因?yàn)槲覀儎?chuàng)建的 ch 是一個(gè)無(wú)緩沖的 channel。因此在執(zhí)行到 ch<-"123",這個(gè) goroutine 就阻塞了，后面的 fmt.Println(<-ch) 沒(méi)有辦法得到執(zhí)行。所以將會(huì)報(bào) deadlock 錯(cuò)誤。
如果我們改成這樣，程序就可以執(zhí)行
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 1)
ch <- "123"
fmt.Println(<-ch)
}
執(zhí)行
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，但是程序還是會(huì)死鎖，因?yàn)榫彌_區(qū)滿了，goroutine 阻塞掛起。第二個(gè) ch<- "123" 是沒(méi)有辦法寫入的。
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox642690323/main.go:10 +0x80Program exited.
因此，利用 channel 的緩沖設(shè)定，我們就可以來(lái)實(shí)現(xiàn)并發(fā)的限制。我們只要在執(zhí)行并發(fā)的同時(shí)，往一個(gè)帶有緩沖的 channel 里寫入點(diǎn)東西（隨便寫啥，內(nèi)容不重要）。讓并發(fā)的 goroutine 在執(zhí)行完成后把這個(gè) channel 里的東西給讀走。這樣整個(gè)并發(fā)的數(shù)量就講控制在這個(gè) channel 的緩沖區(qū)大小上。
比如我們可以用一個(gè) bool 類型的帶緩沖 channel 作為并發(fā)限制的計(jì)數(shù)器。
chLimit := make(chan bool, 1)
然后在并發(fā)執(zhí)行的地方，每創(chuàng)建一個(gè)新的 goroutine，都往 chLimit 里塞個(gè)東西。
for i, sleeptime := range input {
chs[i] = make(chan string, 1)
chLimit <- true
go limitFunc(chLimit, chs[i], i, sleeptime, timeout)
}
這里通過(guò) go 關(guān)鍵字并發(fā)執(zhí)行的是新構(gòu)造的函數(shù)。他在執(zhí)行完原來(lái)的 Run() 后，會(huì)把 chLimit 的緩沖區(qū)里給消費(fèi)掉一個(gè)。
limitFunc := func(chLimit chan bool, ch chan string, task_id, sleeptime, timeout int) {
Run(task_id, sleeptime, timeout, ch)
<-chLimit
}
這樣一來(lái)，當(dāng)創(chuàng)建的 goroutine 數(shù)量到達(dá) chLimit 的緩沖區(qū)上限后。主 goroutine 就掛起阻塞了，直到這些 goroutine 執(zhí)行完畢，消費(fèi)掉了 chLimit 緩沖區(qū)中的數(shù)據(jù)，程序才會(huì)繼續(xù)創(chuàng)建新的 goroutine。我們并發(fā)數(shù)量限制的目的也就達(dá)到了。
以下是完整代碼
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))
}
運(yùn)行結(jié)果
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 耗時(shí) 2 秒超時(shí)。task 2 耗時(shí) 1 秒。總耗時(shí) 5 秒。并發(fā)限制生效了。
如果我們修改并發(fā)限制為 2
chLimit := make(chan bool, 2)
運(yùn)行結(jié)果
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 并發(fā)執(zhí)行，耗時(shí) 2秒。task 2 耗時(shí) 1秒?？偤臅r(shí) 3 秒。符合預(yù)期。
有沒(méi)有注意到代碼里有個(gè)地方和之前不同。這里，用了一個(gè)帶緩沖的 channel
chs[i] = make(chan string, 1)
還記得上面的例子么。如果 channel 不帶緩沖，那么直到他被消費(fèi)掉之前，這個(gè) goroutine 都會(huì)被阻塞掛起。
然而如果這里的并發(fā)限制，也就是 chLimit 生效阻塞了主 goroutine，那么后面消費(fèi)這些數(shù)據(jù)的代碼并不會(huì)執(zhí)行到。。。于是就 deadlock 拉！
for _, ch := range chs {
fmt.Println(<-ch)
}
所以給他一個(gè)緩沖就好了。
以上就是本文的全部?jī)?nèi)容，希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
Golang實(shí)現(xiàn)程序優(yōu)雅退出的方法詳解
項(xiàng)目開發(fā)過(guò)程中，隨著需求的迭代，代碼的發(fā)布會(huì)頻繁進(jìn)行，在發(fā)布過(guò)程中，Golang如何讓程序做到優(yōu)雅的退出？本文就來(lái)詳細(xì)為大家講講2022-06-06
一文詳解golang通過(guò)io包進(jìn)行文件讀寫
這篇文章主要介紹了golang通過(guò)io包進(jìn)行文件讀寫文中有詳細(xì)的代碼示例。對(duì)學(xué)習(xí)或工資有很好的幫助，需要的小伙伴可以參考閱讀一下2023-04-04
MatrixOne由Go語(yǔ)言所開發(fā)是一個(gè)新一代超融合異構(gòu)數(shù)據(jù)庫(kù)，致力于打造單一架構(gòu)處理TP、AP、流計(jì)算等多種負(fù)載的極簡(jiǎn)大數(shù)據(jù)引擎，今天通過(guò)本文給大家介紹Go匯編語(yǔ)法和MatrixOne使用，感興趣的朋友一起看看吧2022-04-04
使用 Go 開發(fā)應(yīng)用的時(shí)候,有時(shí)會(huì)遇到需要讀取靜態(tài)資源的情況,如果不打包處理這種靜態(tài)文件：發(fā)布單獨(dú)掛載這種靜態(tài)文件相對(duì)比較麻煩,就有人會(huì)想辦法把靜態(tài)資源文件打包進(jìn) Go 的程序文件中,下面介紹兩種打包方式：go-bindata、go:embed,需要的朋友可以參考下2024-04-04
淺析Go語(yǔ)言bitset的實(shí)現(xiàn)原理
bitset包是一個(gè)將非負(fù)整數(shù)映射到布爾值的位的集合，這篇文章主要通過(guò)開源包bitset來(lái)為大家分析一下位集合的設(shè)計(jì)和實(shí)現(xiàn)，感興趣的可以學(xué)習(xí)一下2023-08-08
這篇文章主要為大家介紹了go實(shí)現(xiàn)腳本解釋器gscript示例代碼，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-07-07
使用Gin框架返回JSON、XML和HTML數(shù)據(jù)
Gin是一個(gè)高性能的Go語(yǔ)言Web框架,它不僅提供了簡(jiǎn)潔的API,還支持快速的路由和中間件處理,在Web開發(fā)中,返回JSON、XML和HTML數(shù)據(jù)是非常常見的需求,本文將介紹如何使用Gin框架來(lái)返回這三種類型的數(shù)據(jù),需要的朋友可以參考下2024-08-08
與C語(yǔ)言一樣，Go語(yǔ)言中同樣有指針，通過(guò)指針，我們可以只傳遞變量的內(nèi)存地址，而不是傳遞整個(gè)變量，這在一定程度上可以節(jié)省內(nèi)存的占用。本文將通過(guò)示例詳細(xì)講講Golang的指針用法，需要的可以參考一下2022-07-07
go build -tags構(gòu)建約束試驗(yàn)示例解析
這篇文章主要為大家介紹了go build -tags構(gòu)建約束試驗(yàn)示例解析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪2023-09-09
Go語(yǔ)言擴(kuò)展原語(yǔ)之Semaphore的用法詳解
Go語(yǔ)言的擴(kuò)展包中提供了帶權(quán)重的信號(hào)量?semaphore.Weighted，讓我們可以按照不同的權(quán)重管理資源的訪問(wèn)，下面小編就來(lái)和大家聊聊它們的具體用法吧2023-07-07