go 语言如何关闭正在运行的协程？谢谢

package main

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

func workRoutine(work chan string, done chan string, wg *sync.WaitGroup) {
	select {
	case donemsg := <-done:
		fmt.Println(donemsg)
	case msg := <-work:
		//这里将有大量工作可能半个小时都未必执行完，这样 done 这个 channel 就无法收到退出信号
		for i := 0; i < 100000; i++ {
			fmt.Println(msg)
			time.Sleep(time.Second)
		}
	case <-time.After(time.Second * 1000):
		fmt.Println("timeout")
	}
	wg.Done()
}
func closeWorkRoutine(done chan string, wg *sync.WaitGroup) {
	//目标是 10 秒后希望能关掉 test 这个协程
	time.Sleep(time.Second * 10)
	done <- "done"
	wg.Done()
}
func main() {
	done := make(chan string)
	work := make(chan string, 1)
	wg := sync.WaitGroup{}
	wg.Add(2)
	work <- "work"
	go workRoutine(work, done, &wg)
	go closeWorkRoutine(done, &wg)
	wg.Wait()
}

请参考上面的代码，我现在有两个协程，一个叫 workRoutine ，另一个叫 closeWorkRoutine ，我的目标是希望 closeWorkRoutine 可以在 10 秒后可以关闭 workRoutine 的协程，但是上面这个代码是无法关闭的，因为 work 过于繁重，永远轮不到执行关闭的时候。请问有什么办法可以直接关闭协程，而无需介意当前协程的状态，最好能像线程那样有一个 ID 我可以直接在外部强制关掉，请问我应该如何做呢，谢谢。

hejw19970413

2022-05-07 12:09:31 +08:00

package main

import (
"context"
"time"
)

var work = make(chan struct{})

func workRoutine(ctx context.Context) {

f1 := func(ctx context.Context) {
select {
case <-ctx.Done():
default:

}
}
for {
select {
case <-ctx.Done():
break
case <-work:
// 任务分解，分别限时
c1, _ := context.WithTimeout(ctx, 10*time.Second)
f1(c1)
}
}
}
func main() {
c, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer cancel()
go workRoutine(c)
select {}
}

不知道这样能不能满足你的要求

wunonglin

2022-05-07 12:16:41 +08:00

func workRoutine(work chan string, done chan string, wg *sync.WaitGroup) {
defer wg.Done()
for {
select {
case donemsg := <-done:
fmt.Println(donemsg)
return
case <-time.After(time.Second * 1000):
fmt.Println("timeout")
return
case msg := <-work:
fmt.Println(msg)
time.Sleep(time.Second)
fmt.Println("work done")
}
}
}

这样的？

Jessun

2022-05-07 12:21:01 +08:00

context 要看怎么用，我的建议是将 context 继续向下传递。

"//这里将有大量工作可能半个小时都未必执行完，这样 done 这个 channel 就无法收到退出信号"
这里如果是一个执行很长的代码，从外部你无法干掉的。将 context 继续传入这个函数，以及它的子函数，即 context 来控制整个调用链路上的超时。

根据目前信息，就这个思路最简单了。

zhangfuguan

2022-05-07 14:15:08 +08:00

```go

package main

import (
"log"
"sync"
"time"
)

var wg sync.WaitGroup

func worker(quit <-chan int) {
defer wg.Done()
for {
select {
case <-quit:
log.Printf("收到退出信号")
return // 必须 return ，否则 goroutine 是不会结束的
default:
log.Println("loading...")
time.Sleep(time.Second * 1)
}
}
}

func main() {
quit := make(chan int) // 退出通道

wg.Add(5)

go worker(quit) // work 1
go worker(quit) // work 2
go worker(quit) // work 3
go worker(quit) // work 4
go Done(quit) // 结束所有任务

wg.Wait()
}

func Done(ch chan int) {
defer wg.Done()

time.Sleep(time.Second * 10)
close(ch)
}

```

这样吗？

walleL

2022-05-07 14:41:18 +08:00

//这里将有大量工作可能半个小时都未必执行完，这样 done 这个 channel 就无法收到退出信号
for i := 0; i < 100000; i++ {
fmt.Println(msg)
time.Sleep(time.Second)
}
------
只能将上面这段长时间执行的操作分解，并在步骤间判断是否需要退出。上面已经有朋友讲过了

tianyou666shen

2022-05-07 15:48:52 +08:00

你这等于要在外部强制 kill -9 杀掉这个 goroutine 的效果?
考虑通过退出主协程的方式强制让子协程被杀死这种方式吗.
比方主协程开启 workRoutine 子协程以后,监听信号,当你输入信号时,主协会直接退出,同时子协程也被退出

这是一个专为移动设备优化的页面（即为了让你能够在 Google 搜索结果里秒开这个页面），如果你希望参与 V2EX 社区的讨论，你可以继续到 V2EX 上打开本讨论主题的完整版本。

https://www.v2ex.com/t/851321