Golang 探索对Goroutine的控制方法(详解)
前言
在golang中，只需要在函数调用前加上关键字go即可创建一个并发任务单元，而这个新建的任务会被放入队列中，等待调度器安排。相比系统的mb级别线程栈，goroutine的自定义栈只有2kb，这使得我们能够轻易创建上万个并发任务，如此对性能提升不少。但随之而来的有以下几个问题：
如何等待所有goroutine的退出
如何限制创建goroutine的数量（信号量实现）
怎么让goroutine主动退出
探索——如何从外部杀死goroutine
本文记录了笔者就以上几个问题进行探究的过程，文中给出了大部分问题的解决方案，同时也抛出了未解决的问题，期待与各位交流：p
准备
开始之前先定义一个常量const n=100以及一个heavywork函数，假定该函数具有极其冗长、复杂度高、难以解耦的特性
func heavywork(id int) {
rand.seed(int64(id))
interval := time.duration(rand.intn(3)+1) * time.second
time.sleep(interval)
fmt.printf("heavywork %-3d cost %v\n", id, interval)
}
以上定义的内容将在之后的代码中直接使用以缩减篇幅，大部分完整代码可在 github: explore-goroutine 中找到
如何等待所有goroutine的退出
"do not communicate by sharing memory; instead, share memory by communicating"——go的一大设计哲学《share memory by communicating》
翻译成中文就是，用通信来共享内存数据，而不要通过共享内存数据来进行通信。
go中的goroutines和channel提供了一种优雅而独特的结构化并发软件的方法，我们可以利用通道(channel)的特性，来实现当前等待goroutine的操作。但是channel并不是当前这个场景的最佳方案，用它来实现的方式是稍显笨拙的，需要知道确定个数的goroutine，同时稍不注意就极易产生死锁，代码如下：
// "talk is cheap, show me the code."
func main() {
waitchan := make(chan int, 1)
for i := 0; i < n; i++ {
go func(n int) {
heavywork(n)
waitchan <- 1
}(i)
}
cnt := 0
for range waitchan {
cnt++
if cnt == n {
break
}
}
close(waitchan)
fmt.println("finished")
}
上述代码使用了一个缓存大小为1的通道(channel)，创建n个goroutine用于运行heavywork，每个任务完成后向waitchan写入一个数据，在收到n个完成信号后退出。
但事实上比较优雅的方式是使用go标准库sync，其中提供了专门的解决方案sync.waitgroup用于等待一个goroutines集合的结束
// "talk is cheap, show me the code."
func main() {
wg := sync.waitgroup{}
for i := 0; i < n; i++ {
wg.add(1)
go func(n int) {
defer wg.done()
heavywork(n)
}(i)
}
wg.wait()
fmt.println("finished")
}
关于sync.waitgroup的具体使用请参照官方文档[godoc] sync.waitgroup ，这里不再赘述
如何限制goroutine的创建数量（信号量实现）
信号量(semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。
其中v操作会增加信号量的数值即释放资源，而p操作会减少它即占用资源
那么非常容易想到的就是利用channel（通道）缓存有限的特性，它允许我们可以自实现一个简单的数量控制，就如同使用信号量一般，在这基础再加上前面提到的sync.waitgroup，我们可以打出一套组合拳，提供可阻塞的信号量pv操作，能够实现固定创建goroutine数量并且支持等待当前goroutine的退出。结构体定义如下：
type semaphore struct {
threads chan int
wg sync.waitgroup
}
而p操作只需在channel中加入一个元素同时调用waitgroup.add即可，这一操作完成对资源的申请
func (sem *semaphore) p() {
sem.threads <- 1
sem.wg.add(1)
}
相反则是v操作，进行资源的释放
func (sem *semaphore) v() {
sem.wg.done()
<-sem.threads
}
wait则阻塞等待直到当前所有资源都归还，直接调用waitgroup的方法即可
func (sem *semaphore) wait() {
sem.wg.wait()
}
完整代码可以在 github: semaphore 中查看
利用上面的信号量就可以做到，在一个时刻的goroutines数量不会超过信号量值的大小，而某个goroutine退出后将返还占用的信号量，而正在等待的goroutine就可以立即申请，下图形象地展现了运行时的状态
怎么让goroutine主动退出
对于goroutine的主动退出，比较友好的做法就是循环监听一个channel，通过类似信号的方式来告知goroutine的”该退出了“，然后goroutine自己主动退出，这种做法在网上十分常见，也是golang官方推荐的做法，思想也很简单。
func main() {
ok, quit := make(chan int, 1), make(chan int, 1)
go func() {
i := 0
for {
select {
case <-quit:
ok <- 1
return
default:
heavywork(i)
i++
}
}
}()
time.sleep(5 * time.second)
quit <- 1
<-ok
}
运行结果如下图
探索——如何从外部杀死goroutine
上面讲了一些关于goroutines和channel的简单使用，接下来终于写到本文的重点了。笔者并没有解决如何从外部杀死一个goroutine，但记录了尝试“杀死”中的可行或不可行方法，希望对各位有所帮助。
因为近期在开发中遇到这样一个问题，当一个函数是极其冗长、复杂度高、难以解耦的顺序结构代码时（例如某个极其复杂无循环结构的加密算法），而且由于数据量巨大，需要反复调用该函数，由于每运行一次，程序都会消耗大量的时间、空间，那么当一个任务已经被用户抛弃时，如何才能抛弃仍在做着无用功的goroutine？
为了达到“杀死goroutine”的目的，笔者做了很多尝试，如
select结构（条件实现）
panic退出机制（失败）
获取pid杀死（失败）
ptrace单步调试（失败）
...（失败）
利用select语句实现
关于“如何杀死goroutine”，网上有一部分答案就是利用select实现的，但是这种方式实现的代码并不适用于服务类的程序，但是对于一般非服务类程序的确能够实现杀死goroutine的效果，代码如下：
func main() {
wrapper := func() chan int {
c := make(chan int)
go func() {
heavywork(0)
c <- 1
}()
return c
}
select {
case <-wrapper():
case <-time.after(1 * time.second):
fmt.println("time limit exceed")
}
// time.sleep(3 * time.second)
}
但是一旦主函数没有立即退出，而是作为某种服务而继续运行时，这里删除了main函数的最后一行注释time.sleep(3 * time.second)，延迟三秒后退出。可以看见尽管已经超时并输出"time limit exceed"之后，heavywork在main函数没退出前依旧在运行。效果如下
所以使用select-timeout的方式比较适合实时退出类型的程序，能够实现一定程度上的并发控制，
小结
就目前而言，还没有完美的方案来解决控制goroutine的问题，事实上go似乎并不允许和推荐人们直接控制goroutine，所以暂时还无法做到从外部直接控制goroutine的生命周期，所以比较推荐的做法还是只能通过goroutine主动退出的方法，循环监听channel，在发出退出信号后最多只消耗一轮资源后就退出，但这就要求该代码具有循环结构否则就很难使用。有更好解决方案的朋友，请务必告诉我！
以上这篇golang 探索对goroutine的控制方法(详解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。