Golang 并发限制和超时限制
我们先来看一个简单的并发实例：
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)
输出结果：
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的并发就是这么简单。
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运行时间太长了，那肯定会拖累主gorotine被阻塞住，整个程序就挂起在那儿了。因此我们需要有超时的控制。
通常我们可以通过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)
}这代代码执行将报错
atal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox531498664/main.go:9 +0x60
Program exited.这是因为我们创建的ch是一个无缓冲的channel。因此在执行到ch <- "123",这个gorountine就阻塞了，后面的fmt.Printfln(<-ch)没有办法得到执行。所以将会包deadlock错误。
如果我们改成这样，程序就可以执行
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 1)
ch <- "123"
fmt.Println(<-ch)
}执行结果：123
如果我们改成这样
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里写入点东西。让并发的gorountine在执行完成后把这个channel里的东西给读走。这样整个并发的数量就讲控制在这个channel的缓冲区大小上。
比如我们可以用一个bool类型的带缓冲的channel作为并发限制的计数器。
chLimit := make(chan bool, 1);
然后在并发执行的地方，每创建一个新的goroutine，都往chLimit里塞个东西。
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就挂起阻塞了，直到这些gorountine执行完毕，消费掉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秒超时。task2耗时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.参考：
https://www.yuque.com/docs/share/a5fba4dc-dfc4-4850-8d2a-bf1d807c1ae3