前言
我们有很多情况下需要主动关闭goroutine，如需要实现一个系统自动熔断的功能就需要主动关闭goroutine
为什么要中断GoRoutine?
场景：
俩个相互依赖的的操作，“依赖”是指如果其中一个失败，那么另一个就没有意义，而不是第二个操作依赖第一个操作的结果（那种情况下，两个操作不能并行）。在这种情况下，如果我们很早就知道其中一个操作失败，那么我们就会希望能取消所有相关的操作。
goroutine介绍
goroutine是Go语言实现并发编程的利器，是 Go语言中的轻量级线程实现，由 Go 运行时（runtime）管理，简单的一个指令go function就能启动一个goroutine；Go 程序会智能地将 goroutine 中的任务合理地分配给每个 CPU。
但是，Go语言并没有提供终止goroutine的接口，也就是说，我们不能从外部去停止一个goroutine，只能由goroutine内部退出(main函数终止除外)；
几种停止的办法
1. 使用 for-range
for-range 从 channel 上接收值，直到 channel 关闭，该结构在Go并发编程中很常用，这对于从单一通道上获取数据去执行某些任务是十分方便的
package main import ( "fmt" "sync" ) //源码&面试>>https://javapub.blog.csdn.net/category_11938137.html var wg sync.WaitGroup //等待组，用来阻塞程序 func worker(ch chan int) { defer wg.Done() //等待组 -1 for v := range ch { fmt.Println(v) } } func main() { ch := make(chan int) wg.Add(1) //等待组 +1 go worker(ch) for i := 0; i < 5; i++ { ch <- i } close(ch) //必须要加close，因为在打印完0、1、2、3、4后会发生阻塞，直到chan关闭。 wg.Wait() }
去掉close的情况
2. 使用 for-select (向退出通道发出退出信号)
当channel比较多时，for-range结构借不是很方便了；
Go语言提供了另外一种和channel相关的语法: select；
select能够让goroutine在多个通信操作上等待(可以理解为监听多个channel)；
由于这个特性，for-select结构在Go并发编程中使用的频率很高；
我在使用Go的开发中，这是我用的最多的一种组合形式:
这里用 quit通道接收退出信号。
package main import ( "fmt" "sync" "time" ) var wg sync.WaitGroup func worker(in, quit <-chan int) { defer wg.Done() for { select { case <-quit: fmt.Println("收到退出信号") return //必须return，否则goroutine不会结束 case v := <-in: fmt.Println(v) } } } func main() { quit := make(chan int) //退出通道 in := make(chan int) wg.Add(1) go worker(in, quit) for i := 0; i < 3; i++ { in <- i time.Sleep(1 * time.Second) } quit <- 1 //想通道写入退出信号 wg.Wait() }
3. 使用for-select(关闭退出通道)
当我们就需要向 quit 通道中发送100次数据，如果再用以上的代码就很麻烦，有一个很简单的方法，关闭 channel，这样所有监听 quit channel 的 goroutine 就都会收到关闭信号。
package main //源码&面试>>https://javapub.blog.csdn.net/category_11938137.html import ( "fmt" "sync" "time" ) var wg sync.WaitGroup func worker(in, quit <-chan int) { defer wg.Done() for { select { case <-quit: fmt.Println("收到退出信号") return //必须return，否则goroutine不会结束 case v := <-in: fmt.Println(v) } } } func main() { quit := make(chan int) //退出通道 in := make(chan int) wg.Add(1) go worker(in, quit) for i := 0; i < 3; i++ { in <- i time.Sleep(1 * time.Second) } // quit <- 1 //想通道写入退出信号 close(quit) // 直接关闭通道，程序退出 wg.Wait() }
4. 使用for-select(关闭多个channel)
如果select上监听了多个通道，需要所有的通道都关闭后才能结束goroutine，这里就利用select的一个特性，select不会在nil的通道上进行等待，因此将channel赋值为nil即可，此外，还需要利用channel的ok值。
package main //源码&面试>>https://javapub.blog.csdn.net/category_11938137.html import ( "fmt" "sync" "time" ) var wg sync.WaitGroup func worker(in1, in2 <-chan int) { defer wg.Done() for { select { case v, ok := <-in1: if !ok { fmt.Println("收到退出信号1") in1 = nil } fmt.Println(v) case v, ok := <-in2: if !ok { fmt.Println("收到退出信号2") in2 = nil } fmt.Println(v) } if in1 == nil && in2 == nil { return } } } func main() { in1 := make(chan int) in2 := make(chan int) wg.Add(2) go worker(in1, in2) go worker(in1, in2) for i := 0; i < 3; i++ { in1 <- i time.Sleep(1 * time.Second) in2 <- i } close(in1) close(in2) wg.Wait() }
5. 使用context包
context包是官方提供的一个用于控制多个goroutine写作的包；
使用context的cancel信号，可以终止goroutine的运行，context是可以向下传递的
package main //源码&面试>>https://javapub.blog.csdn.net/category_11938137.html import ( "context" "errors" "fmt" "time" ) func operation1(ctx context.Context) error { // 让我们假设这个操作会因为某种原因失败 // 我们使用time.Sleep来模拟一个资源密集型操作 time.Sleep(100 * time.Millisecond) return errors.New("failed") } func operation2(ctx context.Context) { // 我们使用在前面HTTP服务器例子里使用过的类似模式 select { case <-time.After(500 * time.Millisecond): fmt.Println("done") case <-ctx.Done(): fmt.Println("halted operation2") } } func main() { // 新建一个上下文 ctx := context.Background() // 在初始上下文的基础上创建一个有取消功能的上下文 ctx, cancel := context.WithCancel(ctx) //需要取消时，就调用cancel()，发出取消事件。 // 在不同的goroutine中运行operation2 go func() { operation2(ctx) }() err := operation1(ctx) fmt.Println(err) // 如果这个操作返回错误，取消所有使用相同上下文的操作 if err != nil { cancel() } } // func main() { // // 创建一个监听8000端口的服务器 // http.ListenAndServe(":8000", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // ctx := r.Context() // // 输出到 STDOUT 展示处理已经开始 // fmt.Fprint(os.Stdout, "processing request\n") // // 通过select监听多个channel // select { // case <-time.After(2 * time.Second): // // 如果两秒后接受到了一个消息后，意味请求已经处理完成 // // 我们写入"request processed"作为响应 // w.Write([]byte("request processed")) // case <-ctx.Done(): // // 如果处理完成前取消了，在STDERR中记录请求被取消的消息 // fmt.Fprint(os.Stderr, "request cancelled\n") // } // })) // }
