详解Golang 中的并发限制与超时控制
前言
上回在用Go写一个轻量级的ssh批量操作工具里提及过，我们做Golang并发的时候要对并发进行限制，对goroutine的执行要有超时控制。那会没有细说，这里展开讨论一下。
以下示例代码全部可以直接在TheGoPlayground上运行测试：
并发
我们先来跑一个简单的并发看看
packagemain
import(
"fmt"
"time"
)
funcrun(task_id,sleeptimeint,chchanstring){
time.Sleep(time.Duration(sleeptime)*time.Second)
ch<-fmt.Sprintf("taskid%d,sleep%dsecond",task_id,sleeptime)
return
}
funcmain(){
input:=[]int{3,2,1}
ch:=make(chanstring)
startTime:=time.Now()
fmt.Println("Multirunstart")
fori,sleeptime:=rangeinput{
gorun(i,sleeptime,ch)
}
forrangeinput{
fmt.Println(<-ch)
}
endTime:=time.Now()
fmt.Printf("Multisshfinished.Processtime%s.Numberoftasksis%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(chanstring)
channel的缓冲，我们一会再说，先看看刚才看看执行的结果。
Multirunstart taskid2,sleep1second taskid1,sleep2second taskid0,sleep3second Multisshfinished.Processtime3s.Numberoftasksis3 Programexited.
三个goroutine`分别sleep了3，2，1秒。但总耗时只有3秒。所以并发生效了，go的并发就是这么简单。
按序返回
刚才的示例中，我执行任务的顺序是0，1，2。但是从channel中返回的顺序却是2，1，0。这很好理解，因为task2执行的最快嘛，所以先返回了进入了channel，task1次之，task0最慢。
如果我们希望按照任务执行的顺序依次返回数据呢？可以通过一个channel数组（好吧，应该叫切片）来做，比如这样
packagemain
import(
"fmt"
"time"
)
funcrun(task_id,sleeptimeint,chchanstring){
time.Sleep(time.Duration(sleeptime)*time.Second)
ch<-fmt.Sprintf("taskid%d,sleep%dsecond",task_id,sleeptime)
return
}
funcmain(){
input:=[]int{3,2,1}
chs:=make([]chanstring,len(input))
startTime:=time.Now()
fmt.Println("Multirunstart")
fori,sleeptime:=rangeinput{
chs[i]=make(chanstring)
gorun(i,sleeptime,chs[i])
}
for_,ch:=rangechs{
fmt.Println(<-ch)
}
endTime:=time.Now()
fmt.Printf("Multisshfinished.Processtime%s.Numberoftasksis%d",endTime.Sub(startTime),len(input))
}
运行结果，现在输出的次序和输入的次序一致了。
Multirunstart
taskid0,sleep3second
taskid1,sleep2second
taskid2,sleep1second
Multisshfinished.Processtime3s.Numberoftasksis3
Programexited.
超时控制
刚才的例子里我们没有考虑超时。然而如果某个goroutine运行时间太长了，那很肯定会拖累主goroutine被阻塞住，整个程序就挂起在那儿了。因此我们需要有超时的控制。
通常我们可以通过select+time.After来进行超时检查，例如这样，我们增加一个函数Run()，在Run()中执行gorun()。并通过select+time.After进行超时判断。
packagemain
import(
"fmt"
"time"
)
funcRun(task_id,sleeptime,timeoutint,chchanstring){
ch_run:=make(chanstring)
gorun(task_id,sleeptime,ch_run)
select{
casere:=<-ch_run:
ch<-re
case<-time.After(time.Duration(timeout)*time.Second):
re:=fmt.Sprintf("taskid%d,timeout",task_id)
ch<-re
}
}
funcrun(task_id,sleeptimeint,chchanstring){
time.Sleep(time.Duration(sleeptime)*time.Second)
ch<-fmt.Sprintf("taskid%d,sleep%dsecond",task_id,sleeptime)
return
}
funcmain(){
input:=[]int{3,2,1}
timeout:=2
chs:=make([]chanstring,len(input))
startTime:=time.Now()
fmt.Println("Multirunstart")
fori,sleeptime:=rangeinput{
chs[i]=make(chanstring)
goRun(i,sleeptime,timeout,chs[i])
}
for_,ch:=rangechs{
fmt.Println(<-ch)
}
endTime:=time.Now()
fmt.Printf("Multisshfinished.Processtime%s.Numberoftaskis%d",endTime.Sub(startTime),len(input))
}
运行结果，task0和task1已然超时
Multirunstart
taskid0,timeout
taskid1,timeout
tasiid2,sleep1second
Multisshfinished.Processtime2s.Numberoftaskis3
Programexited.
并发限制
如果任务数量太多，不加以限制的并发开启goroutine的话，可能会过多的占用资源，服务器可能会爆炸。所以实际环境中并发限制也是一定要做的。
一种常见的做法就是利用channel的缓冲机制——开始的时候我们提到过的那个。
我们分别创建一个带缓冲和不带缓冲的channel看看
ch:=make(chanstring)//这是一个无缓冲的channel，或者说缓冲区长度是0 ch:=make(chanstring,1)//这是一个带缓冲的channel,缓冲区长度是1
这两者的区别在于，如果channel没有缓冲，或者缓冲区满了。goroutine会自动阻塞，直到channel里的数据被读走为止。举个例子
packagemain
import(
"fmt"
)
funcmain(){
ch:=make(chanstring)
ch<-"123"
fmt.Println(<-ch)
}
这段代码执行将报错
fatalerror:allgoroutinesareasleep-deadlock!
goroutine1[chansend]:
main.main()
/tmp/sandbox531498664/main.go:9+0x60Programexited.
这是因为我们创建的ch是一个无缓冲的channel。因此在执行到ch<-"123",这个goroutine就阻塞了，后面的fmt.Println(<-ch)没有办法得到执行。所以将会报deadlock错误。
如果我们改成这样，程序就可以执行
packagemain
import(
"fmt"
)
funcmain(){
ch:=make(chanstring,1)
ch<-"123"
fmt.Println(<-ch)
}
执行
123
Programexited.
如果我们改成这样
packagemain
import(
"fmt"
)
funcmain(){
ch:=make(chanstring,1)
ch<-"123"
ch<-"123"
fmt.Println(<-ch)
fmt.Println(<-ch)
}
尽管读取了两次channel，但是程序还是会死锁，因为缓冲区满了，goroutine阻塞挂起。第二个ch<-"123"是没有办法写入的。
fatalerror:allgoroutinesareasleep-deadlock!
goroutine1[chansend]:
main.main()
/tmp/sandbox642690323/main.go:10+0x80Programexited.
因此，利用channel的缓冲设定，我们就可以来实现并发的限制。我们只要在执行并发的同时，往一个带有缓冲的channel里写入点东西（随便写啥，内容不重要）。让并发的goroutine在执行完成后把这个channel里的东西给读走。这样整个并发的数量就讲控制在这个channel的缓冲区大小上。
比如我们可以用一个bool类型的带缓冲channel作为并发限制的计数器。
chLimit:=make(chanbool,1)
然后在并发执行的地方，每创建一个新的goroutine，都往chLimit里塞个东西。
fori,sleeptime:=rangeinput{
chs[i]=make(chanstring,1)
chLimit<-true
golimitFunc(chLimit,chs[i],i,sleeptime,timeout)
}
这里通过go关键字并发执行的是新构造的函数。他在执行完原来的Run()后，会把chLimit的缓冲区里给消费掉一个。
limitFunc:=func(chLimitchanbool,chchanstring,task_id,sleeptime,timeoutint){
Run(task_id,sleeptime,timeout,ch)
<-chLimit
}
这样一来，当创建的goroutine数量到达chLimit的缓冲区上限后。主goroutine就挂起阻塞了，直到这些goroutine执行完毕，消费掉了chLimit缓冲区中的数据，程序才会继续创建新的goroutine。我们并发数量限制的目的也就达到了。
以下是完整代码
packagemain
import(
"fmt"
"time"
)
funcRun(task_id,sleeptime,timeoutint,chchanstring){
ch_run:=make(chanstring)
gorun(task_id,sleeptime,ch_run)
select{
casere:=<-ch_run:
ch<-re
case<-time.After(time.Duration(timeout)*time.Second):
re:=fmt.Sprintf("taskid%d,timeout",task_id)
ch<-re
}
}
funcrun(task_id,sleeptimeint,chchanstring){
time.Sleep(time.Duration(sleeptime)*time.Second)
ch<-fmt.Sprintf("taskid%d,sleep%dsecond",task_id,sleeptime)
return
}
funcmain(){
input:=[]int{3,2,1}
timeout:=2
chLimit:=make(chanbool,1)
chs:=make([]chanstring,len(input))
limitFunc:=func(chLimitchanbool,chchanstring,task_id,sleeptime,timeoutint){
Run(task_id,sleeptime,timeout,ch)
<-chLimit
}
startTime:=time.Now()
fmt.Println("Multirunstart")
fori,sleeptime:=rangeinput{
chs[i]=make(chanstring,1)
chLimit<-true
golimitFunc(chLimit,chs[i],i,sleeptime,timeout)
}
for_,ch:=rangechs{
fmt.Println(<-ch)
}
endTime:=time.Now()
fmt.Printf("Multisshfinished.Processtime%s.Numberoftaskis%d",endTime.Sub(startTime),len(input))
}
运行结果
Multirunstart
taskid0,timeout
taskid1,timeout
taskid2,sleep1second
Multisshfinished.Processtime5s.Numberoftaskis3
Programexited.
chLimit的缓冲是1。task0和task1耗时2秒超时。task2耗时1秒。总耗时5秒。并发限制生效了。
如果我们修改并发限制为2
chLimit:=make(chanbool,2)
运行结果
Multirunstart
taskid0,timeout
taskid1,timeout
taskid2,sleep1second
Multisshfinished.Processtime3s.Numberoftaskis3
Programexited.
task0,task1并发执行，耗时2秒。task2耗时1秒。总耗时3秒。符合预期。
有没有注意到代码里有个地方和之前不同。这里，用了一个带缓冲的channel
chs[i]=make(chanstring,1)
还记得上面的例子么。如果channel不带缓冲，那么直到他被消费掉之前，这个goroutine都会被阻塞挂起。
然而如果这里的并发限制，也就是chLimit生效阻塞了主goroutine，那么后面消费这些数据的代码并不会执行到。。。于是就deadlock拉！
for_,ch:=rangechs{
fmt.Println(<-ch)
}
所以给他一个缓冲就好了。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。