blocks|key|829769|text|通常，您向goroutine传递一个(可能是单独的)信号通道。当您希望goroutine停止时，该信号通道用于将一个值推入。goroutine定期对该频道进行民意调查。一旦检测到信号，它就会退出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829770|quit+:=+make(chan+bool)
go+func()+{
++++for+{
++++++++select+{
++++++++case+<-+quit:
++++++++++++return
++++++++default:
++++++++++++//+Do+other+stuff
++++++++}
++++}
}()

//+Do+stuff

//+Quit+goroutine
quit+<-+true|code-block|syntax|javascript|829771|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Typically, you pass the goroutine a (possibly separate) signal channel. That signal channel is used to push a value into when you want the goroutine to stop. The goroutine polls that channel regularly. As soon as it detects a signal, it quits.

<pre><code>quit := make(chan bool)
go func() {
 for {
 select {
 case &lt;- quit:
 return
 default:
 // Do other stuff
 }
 }
}()

// Do stuff

// Quit goroutine
quit &lt;- true
</code></pre>

blocks|key|829875|text|你不能从外面杀死一只大猩猩。您可以向goroutine发出停止使用通道的信号，但是goroutine上没有句柄来执行任何类型的元管理。Goroutines的目的是合作解决问题，所以杀死一个行为不端的人几乎永远不会是一个足够的反应。如果您想要隔离以获得健壮性，那么您可能需要一个进程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829876|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You can't kill a goroutine from outside. You can signal a goroutine to stop using a channel, but there's no handle on goroutines to do any sort of meta management. Goroutines are intended to cooperatively solve problems, so killing one that is misbehaving would almost never be an adequate response. If you want isolation for robustness, you probably want a process.

blocks|key|829945|text|我知道这个答案已经被接受了，但我想我还是把我的2分钱投进去吧。我喜欢使用tomb包。它基本上是一个超级退出通道，但它也做了一些很好的事情，比如传回任何错误。受控制的例程仍然具有检查远程终止信号的责任。这是不可能获得一个"id“的goroutine，并杀死它，如果它的行为不端(即:卡在一个无限循环)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|829946|下面是我测试的一个简单示例：|829947|package+main

import+(
++"launchpad.net/tomb"
++"time"
++"fmt"
)

type+Proc+struct+{
++Tomb+tomb.Tomb
}

func+(proc+*Proc)+Exec()+{
++defer+proc.Tomb.Done()+//+Must+call+only+once
++for+{
++++select+{
++++case+<-proc.Tomb.Dying():
++++++return
++++default:
++++++time.Sleep(300+*+time.Millisecond)
++++++fmt.Println("Loop+the+loop")
++++}
++}
}

func+main()+{
++proc+:=+&Proc{}
++go+proc.Exec()
++time.Sleep(1+*+time.Second)
++proc.Tomb.Kill(fmt.Errorf("Death+from+above"))
++err+:=+proc.Tomb.Wait()+//+Will+return+the+error+that+killed+the+proc
++fmt.Println(err)
}|code-block|syntax|javascript|829948|输出应如下所示：|829949|#+Loop+the+loop
#+Loop+the+loop
#+Loop+the+loop
#+Loop+the+loop
#+Death+from+above|829950|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.labix.org/2011/10/09/death-of-goroutines-under-control^0|10|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I know this answer has already been accepted, but I thought I'd throw my 2cents in. I like to use the <a href="http://blog.labix.org/2011/10/09/death-of-goroutines-under-control" rel="noreferrer">tomb</a> package. It's basically a suped up quit channel, but it does nice things like pass back any errors as well. The routine under control still has the responsibility of checking for remote kill signals. Afaik it's not possible to get an "id" of a goroutine and kill it if it's misbehaving (ie: stuck in an infinite loop).

Here's a simple example which I tested:

<pre><code>package main

import (
 "launchpad.net/tomb"
 "time"
 "fmt"
)

type Proc struct {
 Tomb tomb.Tomb
}

func (proc *Proc) Exec() {
 defer proc.Tomb.Done() // Must call only once
 for {
 select {
 case &lt;-proc.Tomb.Dying():
 return
 default:
 time.Sleep(300 * time.Millisecond)
 fmt.Println("Loop the loop")
 }
 }
}

func main() {
 proc := &amp;Proc{}
 go proc.Exec()
 time.Sleep(1 * time.Second)
 proc.Tomb.Kill(fmt.Errorf("Death from above"))
 err := proc.Tomb.Wait() // Will return the error that killed the proc
 fmt.Println(err)
}
</code></pre>

The output should look like:

<pre><code># Loop the loop
# Loop the loop
# Loop the loop
# Loop the loop
# Death from above
</code></pre>

blocks|key|830010|text|就我个人而言，我想在goroutine中的通道上使用range：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830011|https://play.golang.org/p/qt48vvDu8cd|offset|length|830012|package+main

import+(
++++"fmt"
++++"sync"
)

func+main()+{
++++var+wg+sync.WaitGroup
++++c+:=+make(chan+bool)
++++wg.Add(1)
++++go+func()+{
++++++++defer+wg.Done()
++++++++for+b+:=+range+c+{
++++++++++++fmt.Printf("Hello+%25t\n",+b)
++++++++}
++++}()
++++c+<-+true
++++c+<-+true
++++close(c)
++++wg.Wait()
}|code-block|syntax|javascript|830013|戴夫为此写了一篇很棒的文章：http://dave.cheney.net/2013/04/30/curious-channels。|830014|entityMap|0|LINK|mutability|MUTABLE|url|1|http://dave.cheney.net/2013/04/30/curious-channels^0|0|0|11|0|0|0|E|1E|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|G|5|H|7|10|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|M|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|C]]|T|$5|P|Q|R|A|$S|U]]]]

Personally, I'd like to use range on a channel in a goroutine:
<a href="https://play.golang.org/p/qt48vvDu8cd" rel="nofollow noreferrer">https://play.golang.org/p/qt48vvDu8cd</a>
<pre><code>package main

import (
 &quot;fmt&quot;
 &quot;sync&quot;
)

func main() {
 var wg sync.WaitGroup
 c := make(chan bool)
 wg.Add(1)
 go func() {
 defer wg.Done()
 for b := range c {
 fmt.Printf(&quot;Hello %t\n&quot;, b)
 }
 }()
 c &lt;- true
 c &lt;- true
 close(c)
 wg.Wait()
}
</code></pre>
Dave has written a great post about this: <a href="http://dave.cheney.net/2013/04/30/curious-channels" rel="nofollow noreferrer">http://dave.cheney.net/2013/04/30/curious-channels</a>.

blocks|key|830103|text|我将提供一种与这里提供的方法略有不同的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830104|我将假设需要停止的goroutine正在执行一些与其他goroutines完全无关的工作。这项工作将由default+select+case表示|offset|length|style|CODE|830105|default:
++++fmt.Println("working")
++++time.Sleep(1+*+time.Second)|code-block|syntax|javascript|830106|另一个goroutine+(在我的示例中是main)决定它应该停止正在执行某些工作的goroutine。你不能真的杀死goroutine。即使您可以，这也不是一个好主意，因为它可能会使goroutine处于不需要的状态。因此，我们必须使用一个通道来传达有人正在向goroutine发出停止信号。|830107|stop+:=+make(chan+struct{})|830108|因为goroutine将持续执行一些工作。我们将使用循环来表示这一点。并且当发送stop信号时，goroutine中断循环。|830109|go+func()+{
L:
++++for+{
++++++++select+{
++++++++case+<-stop:
++++++++++++fmt.Println("stopping")
++++++++++++break+L
++++++++default:
++++++++++++fmt.Println("working")
++++++++++++time.Sleep(1+*+time.Second)
++++++++}
++++}
}()|830110|我们可以使用另一个通道来向main表明goroutine已经停止。下面是完整的示例：|830111|package+main

import+(
++++"fmt"
++++"time"
)

func+main()+{
++++stop+:=+make(chan+struct{})
++++stopped+:=+make(chan+struct{})

++++go+func()+{
++++L:
++++++++for+{
++++++++++++select+{
++++++++++++case+<-stop:
++++++++++++++++fmt.Println("stopping")
++++++++++++++++break+L
++++++++++++default:
++++++++++++++++fmt.Println("working")
++++++++++++++++time.Sleep(1+*+time.Second)
++++++++++++}
++++++++}

++++++++fmt.Println("stopped")
++++++++stopped+<-+struct{}{}
++++}()

++++<-time.After(5+*+time.Second)
++++stop+<-+struct{}{}+//+send+a+signal+to+stop
++++close(stop)
++++<-stopped+//+wait+for+stop
}|830112|main线程产生一个goroutine，以便在一段时间内(在本例中为5秒)执行一些工作。当时间到期时，它会向goroutine发送停止信号，并等待该信号，直到goroutine完全停止。|830113|entityMap^0|0|9|9|R|A|1F|J|0|0|3|9|L|4|16|9|1N|9|2K|9|3N|9|0|0|2|9|1C|9|0|0|D|4|0|0|0|4|A|9|1I|9|27|9|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1B|8|@$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]|$D|1K|E|1L|F|G]|$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1O|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1P|8|@$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]]|9|@]|A|$]]|$1|S|3|T|5|J|7|1U|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1V|8|@$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]|$D|24|E|25|F|G]|$D|26|E|27|F|G]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|11|$]]

I am going to offer a slightly different approach than the ones provided here.
I am going to assume the <code>goroutine</code> that needs to be stopped is performing some work that is not related at all to other <code>goroutines</code>. That work will be represented by the <code>default select case</code>:
<pre class="lang-golang prettyprint-override"><code>default:
 fmt.Println(&quot;working&quot;)
 time.Sleep(1 * time.Second)
</code></pre>
Another <code>goroutine</code> (in my example will be the <code>main</code>) decides that it should stop the <code>goroutine</code> that is performing some work. You cannot really kill the <code>goroutine</code>. Even if you could it would be a bad idea because it could leave the <code>goroutine</code> in an undesired state. So, we have to use a channel to communicate that someone is signaling to the <code>goroutine</code> to stop.
<pre class="lang-golang prettyprint-override"><code>stop := make(chan struct{})
</code></pre>
Since the <code>goroutine</code> will be continuously performing some work. We will use a loop to represent that. And when the stop signal is sent, the <code>goroutine</code> breaks out of the loop.
<pre class="lang-golang prettyprint-override"><code>go func() {
L:
 for {
 select {
 case &lt;-stop:
 fmt.Println(&quot;stopping&quot;)
 break L
 default:
 fmt.Println(&quot;working&quot;)
 time.Sleep(1 * time.Second)
 }
 }
}()
</code></pre>
We can use another channel to indicate to the <code>main</code> that the goroutine has stopped. Here's the full example:
<pre class="lang-golang prettyprint-override"><code>package main

import (
 &quot;fmt&quot;
 &quot;time&quot;
)

func main() {
 stop := make(chan struct{})
 stopped := make(chan struct{})

 go func() {
 L:
 for {
 select {
 case &lt;-stop:
 fmt.Println(&quot;stopping&quot;)
 break L
 default:
 fmt.Println(&quot;working&quot;)
 time.Sleep(1 * time.Second)
 }
 }

 fmt.Println(&quot;stopped&quot;)
 stopped &lt;- struct{}{}
 }()

 &lt;-time.After(5 * time.Second)
 stop &lt;- struct{}{} // send a signal to stop
 close(stop)
 &lt;-stopped // wait for stop
}
</code></pre>
The <code>main</code> thread spawns a <code>goroutine</code> to perform some work for some time (in this case 5 seconds). When the time expires, it sends a stop signal to the <code>goroutine</code> and waits for it until the <code>goroutine</code> is fully stopped.

I have a goroutine that calls a method, and passes returned value on a channel:

<pre><code>ch := make(chan int, 100)
go func(){
 for {
 ch &lt;- do_stuff()
 }
}()
</code></pre>

How do I stop such a goroutine?

How to stop a goroutine

5位重磅专家聚焦 AI 时代开发者核心成长需求，带你深入解锁全栈进化、人机协作关键路径！点击报名到场：<a href="https://cloud.tencent.com/developer/salon/salon-2403/signup" target="_blank">https://cloud.tencent.com/developer/salon/salon-2403/signup</a> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/487c82639d2338df3ef66dfb1450601a.png"/>

腾讯技术创作特训营「年度论坛」正在报名中！

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有一个goroutine，它调用一个方法，并在一个通道上传递返回值：ch := make(chan int, 100)go func(){ for { ch <- do_stuff() }}()我如何阻止这样的goroutine？

问如何停止goroutine
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何停止goroutineEN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何停止goroutine
EN