Golang 并发限制和超时限制 - 《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.

Golang 并发限制和超时限制 - 图1