脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - 详解Golang 中的并发限制与超时控制

详解Golang 中的并发限制与超时控制

2020-05-14 09:51freedomkk_qfeng Golang

这篇文章主要介绍了详解Golang 中的并发限制与超时控制，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

前言

上回在 用 Go 写一个轻量级的 ssh 批量操作工具 里提及过，我们做 Golang 并发的时候要对并发进行限制，对 goroutine 的执行要有超时控制。那会没有细说，这里展开讨论一下。

以下示例代码全部可以直接在 The Go Playground 上运行测试：

并发

我们先来跑一个简单的并发看看

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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 之间交互数据。

?
1
2
ch <- xxx // 向 channel 写入数据
<- ch // 从 channel 中读取数据

channel 分为无缓冲(unbuffered)和缓冲(buffered)两种。例如刚才我们通过如下方式创建了一个无缓冲的 channel。

?
1
ch := make(chan string)

channel 的缓冲，我们一会再说，先看看刚才看看执行的结果。

?
1
2
3
4
5
6
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 数组（好吧，应该叫切片）来做，比如这样

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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 进行超时判断。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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 看看

?
1
2
ch := make(chan string) // 这是一个无缓冲的 channel，或者说缓冲区长度是 0
ch := make(chan string, 1) // 这是一个带缓冲的 channel, 缓冲区长度是 1

这两者的区别在于，如果 channel 没有缓冲，或者缓冲区满了。goroutine 会自动阻塞，直到 channel 里的数据被读走为止。举个例子

?
1
2
3
4
5
6
7
8
9
10
11
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 错误。

如果我们改成这样，程序就可以执行

?
1
2
3
4
5
6
7
8
9
10
11
package main
 
import (
  "fmt"
)
 
func main() {
  ch := make(chan string, 1)
  ch <- "123"
  fmt.Println(<-ch)
}

执行

123

Program exited.

如果我们改成这样

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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 作为并发限制的计数器。

?
1
chLimit := make(chan bool, 1)

然后在并发执行的地方，每创建一个新的 goroutine，都往 chLimit 里塞个东西。

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

这里通过 go 关键字并发执行的是新构造的函数。他在执行完原来的 Run() 后，会把 chLimit 的缓冲区里给消费掉一个。

?
1
2
3
4
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。我们并发数量限制的目的也就达到了。

以下是完整代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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

?
1
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

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

还记得上面的例子么。如果 channel 不带缓冲，那么直到他被消费掉之前，这个 goroutine 都会被阻塞挂起。

然而如果这里的并发限制，也就是 chLimit 生效阻塞了主 goroutine，那么后面消费这些数据的代码并不会执行到。。。于是就 deadlock 拉！

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

所以给他一个缓冲就好了。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://www.jianshu.com/p/42e89de33065

  • golang
  • 超时控制
  • 并发限制

    • 延伸 · 阅读

    精彩推荐
    • GolangGo语言实现自动填写古诗词实例代码

      Go语言实现自动填写古诗词实例代码

      这篇文章主要给大家介绍了关于Go语言实现自动填写古诗词的相关资料，这是最近在项目中遇到的一个需求，文中通过示例代码介绍的非常详细，需要的朋...

      FengY5862020-05-14
    • GolangGO语言字符串处理Strings包的函数使用示例讲解

      GO语言字符串处理Strings包的函数使用示例讲解

      这篇文章主要为大家介绍了GO语言字符串处理Strings包的函数使用示例讲解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加...

      Jeff的技术栈6882022-04-14
    • Golang深入浅析Go中三个点(...)用法

      深入浅析Go中三个点(...)用法

      这篇文章主要介绍了深入浅析Go中三个点(...)用法,需要的朋友可以参考下...

      踏雪无痕SS6472021-11-17
    • GolangGolang实现四种负载均衡的算法(随机,轮询等)

      Golang实现四种负载均衡的算法(随机,轮询等)

      本文介绍了示例介绍了Golang 负载均衡的四种实现，主要包括了随机，轮询，加权轮询负载，一致性hash，感兴趣的小伙伴们可以参考一下...

      Gundy_8442021-08-09
    • Golanggo语言获取系统盘符的方法

      go语言获取系统盘符的方法

      这篇文章主要介绍了go语言获取系统盘符的方法,涉及Go语言调用winapi获取系统硬件信息的技巧,具有一定参考借鉴价值,需要的朋友可以参考下 ...

      无尽海3862020-04-24
    • GolangGo语言range关键字循环时的坑

      Go语言range关键字循环时的坑

      今天小编就为大家分享一篇关于Go语言range关键字循环时的坑，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来...

      benben_20154202020-05-23
    • GolangGo语言基础单元测试与性能测试示例详解

      Go语言基础单元测试与性能测试示例详解

      这篇文章主要为大家介绍了Go语言基础单元测试与性能测试示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助祝大家多多进步...

      枫少文7812021-12-05
    • GolangGolang 语言极简类型转换库cast的使用详解

      Golang 语言极简类型转换库cast的使用详解

      本文我们通过 cast.ToString() 函数的使用，简单介绍了cast 的使用方法，除此之外，它还支持很多其他类型，在这没有多多介绍，对Golang 类型转换库 cast相关知...

      Golang语言开发栈6112021-12-02
    最近更新
    编辑推荐
    阅读排行
    热门标签
    fsnotify 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图