Goroutine Control

在 Go 语言中创建协程（Goroutine）的成本非常低，因此稍不注意就可能创建出大量的协程，一方面会造成资源的浪费，另一方面不容易控制这些协程的状态。

不过，“能力越大，越需要克制”。网络上已经存在一些讲控制 Goroutine 数目的文章，本文通过图示的方式再简单总结一下其基本理念，以便于记忆。

控制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
package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func main() {
    jobsCount := 10
    group := sync.WaitGroup{}
    for i := 0; i < jobsCount; i++ {
        group.Add(1)
        go func(i int) {
            fmt.Printf("hello %d!\n", i)
            time.Sleep(time.Second) // 刻意睡 1 秒钟，模拟耗时
            group.Done()
        }(i)
        fmt.Printf("index: %d,goroutine Num: %d \n", i, runtime.NumGoroutine())
    }
    group.Wait()
    fmt.Println("done!")
}

上面的代码假设有 jobsCount 个任务，通过 for-range 给每个任务创建了一个 Goroutine。为了让主协程等待所有的子协程执行完毕后再退出，使用 sync.WaitGroup 监控所有协程的状态，从而保证主协程结束时所有的子协程已经退出。为了说明问题，上面的代码还输出了 runtime.NumGoroutine() 的值用以表征协程的数量。

运行上面的代码，可以得到类似下面的输出。从下面的输出中我们可以得到两点信息：① 协程的执行顺序是随机的（比如 hello 3 在 hello 4 后面出现）；② 协程的数量递增，最后竟达到了 11 个之多。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
hello 0!
index: 0,goroutine Num: 2 
index: 1,goroutine Num: 3 
hello 1!
index: 2,goroutine Num: 4 
hello 2!
index: 3,goroutine Num: 5 
index: 4,goroutine Num: 6 
index: 5,goroutine Num: 7 
index: 6,goroutine Num: 8 
hello 4!
hello 5!
hello 3!
hello 7!
index: 7,goroutine Num: 9 
index: 8,goroutine Num: 10 
index: 9,goroutine Num: 11 
hello 8!
hello 9!
hello 6!
done!

我们应该怎么理解例一的代码呢？

假如 CPU 只有两个 核，下图展示了为每个 job 创建一个 goroutine 的情况（换句话说，goroutine 的数量是不受控制的）。此种情况虽然生成了很多的 goroutine，但是每个 CPU 核上同一时间只能执行一个 goroutine；当 job 很多且生成了相应数目的 goroutine 后，会出现很多等待执行的 goroutine，从而造成资源上的浪费。

控制Goroutine数量

给每个 job 生成一个 goroutine 的方式显得粗暴了很多，那么可以通过什么样的方式控制 goroutine 的数目呢？其实“例一”小节的代码通过一个 for-range 循环完成了两件事情：①为每个 job 创建 goroutine；②把任务相关的标识传给相应的 goroutine 执行。为了控制 goroutine 的数目，完全可以把上面的两个过程拆分开：a）先通过一个 for-range 循环创建指定数目的 goroutine，b）然后通过 channel/buffered channel 给每个 goroutine 传递任务相关的信息（这里的channel是否缓冲无所谓，主要用到的是 channel 的线程安全特性）。如下图所示。

代码实现上也很简单：一个 for-range 创建指定数目的 goroutine，另一个 for-range 把 job 依次推送到 channel 供 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
package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

func main() {
	jobsCount := 10
	group := sync.WaitGroup{}
	var jobsChan = make(chan int, 3)
	// a) 生成指定数目的 goroutine，每个 goroutine 消费 jobsChan 中的数据
	poolCount := 3
	for i := 0; i < poolCount; i++ {
		go func() {
			for j := range jobsChan {
				fmt.Printf("hello %d\n", j)
				time.Sleep(time.Second)
				group.Done()
			}
		}()
	}
	// b) 把 job 依次推送到 jobsChan 供 goroutine 消费
	for i := 0; i < jobsCount; i++ {
    group.Add(1)
		jobsChan <- i
		fmt.Printf("index: %d,goroutine Num: %d\n", i, runtime.NumGoroutine())
	}
	group.Wait()
	fmt.Println("done!")
}

运行上面的代码可以得到下面类似的输出（可以看到 goroutine 的数量控制在了 4 个）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
index: 0,goroutine Num: 4
index: 1,goroutine Num: 4
hello 1
index: 2,goroutine Num: 4
index: 3,goroutine Num: 4
index: 4,goroutine Num: 4
hello 2
index: 5,goroutine Num: 4
hello 0
hello 3
hello 4
hello 5
index: 6,goroutine Num: 4
index: 7,goroutine Num: 4
index: 8,goroutine Num: 4
hello 6
hello 7
index: 9,goroutine Num: 4
hello 8
hello 9
done!

总结

控制 goroutine 数目的一种简单方式，简单来讲就是：

  1. 通过一个 for-range 创建指定数目的 goroutine
  2. 通过另一个 for-range 把 job 依次推送到 channel 供第一步生成的 goroutine 消费。

为了说明问题，代码示例中输出了 runtime.NumGoroutine()（即 gouroutine 的数目）的变化，更直观地观察效果。