我有一个调用方法的goroutine，并在通道上传递返回值：
ch := make(chan int, 100)
go func(){
for {
ch <- do_stuff()
}
}()
我怎么停止这样的goroutine？
编辑：我在匆忙中写下这个答案，然后才意识到你的问题是关于将值发送给goroutine中的chan。下面的方法可以使用上面建议的额外陈，或使用你已经是双向的陈的事实，你可以只使用一个......
如果您的goroutine仅用于处理来自chan的项目，您可以使用“close”内置和频道的特殊接收表单。
也就是说，一旦你完成在陈上发送项目，你就关闭它。然后在你的goroutine里面你会得到一个额外的参数给接收运算符，它显示了通道是否已经关闭。
这是一个完整的示例（waitgroup用于确保过程继续，直到goroutine完成）：
package main
import "sync"
func main() {
var wg sync.WaitGroup
wg.Add(1)
ch := make(chan int)
go func() {
for {
foo, ok := <- ch
if !ok {
println("done")
wg.Done()
return
}
println(foo)
}
}()
ch <- 1
ch <- 2
ch <- 3
close(ch)
wg.Wait()
}
通常，您传递goroutine（可能是单独的）信号通道。当您希望goroutine停止时，该信号通道用于将值推入。 goroutine定期进行民意调查。一旦检测到信号，它就会退出。
quit := make(chan bool)
go func() {
for {
select {
case <- quit:
return
default:
// Do other stuff
}
}
}()
// Do stuff
// Quit goroutine
quit <- true
你不能从外面杀死goroutine。你可以发信号通知goroutine停止使用一个频道，但是goroutines没有办法进行任何类型的元管理。 Goroutines旨在合作解决问题，因此杀死一个行为不端的人几乎永远不会是一个充分的反应。如果您希望隔离稳健性，那么您可能需要一个进程。
我知道这个答案已经被接受了，但我想我会把我的两个人扔掉。我喜欢使用tomb包。它基本上是一个suped up quit频道，但它做了很好的事情，比如传回任何错误。受控制的程序仍然负责检查远程终止信号。 Afaik它不可能得到一个goroutine的“id”并且如果它行为不端则杀死它（即：陷入无限循环）。
这是我测试的一个简单示例：
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)
}
输出应如下所示：
# Loop the loop
# Loop the loop
# Loop the loop
# Loop the loop
# Death from above
通常，您可以创建一个通道并在goroutine中接收停止信号。
在此示例中有两种创建通道的方法。
context.WithCancel第一个演示，使用channel：
package main
import "fmt"
import "time"
func do_stuff() int {
return 1
}
func main() {
ch := make(chan int, 100)
done := make(chan struct{})
go func() {
for {
select {
case ch <- do_stuff():
case <-done:
close(ch)
return
}
time.Sleep(100 * time.Millisecond)
}
}()
go func() {
time.Sleep(3 * time.Second)
done <- struct{}{}
}()
for i := range ch {
fmt.Println("receive value: ", i)
}
fmt.Println("finish")
}
第二个演示，使用context：
package main
import (
"context"
"fmt"
"time"
)
func main() {
forever := make(chan struct{})
ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
for {
select {
case <-ctx.Done(): // if cancel() execute
forever <- struct{}{}
return
default:
fmt.Println("for loop")
}
time.Sleep(500 * time.Millisecond)
}
}(ctx)
go func() {
time.Sleep(3 * time.Second)
cancel()
}()
<-forever
fmt.Println("finish")
}
就个人而言，我想在goroutine的频道上使用范围：
http://play.golang.org/p/KjG8FLzPoz
戴夫写了一篇很棒的帖子：http://dave.cheney.net/2013/04/30/curious-channels。