メソッドを呼び出し、戻り値をチャネルに渡すゴルーチンがあります。
ch := make(chan int, 100)
go func(){
for {
ch <- do_stuff()
}
}()
このようなゴルーチンを停止するにはどうすればよいですか?
編集:あなたの質問がゴルーチン内のちゃんに値を送ることだと気づく前に、この答えを急いで書きました。以下のアプローチは、上記のように追加のちゃんと使用するか、すでに持っているちゃんが双方向であるという事実を使用して、1つだけを使用することができます...
チャンから出てくるアイテムを処理するためだけにゴルーチンが存在する場合、「close」ビルトインとチャネルの特別な受信フォームを使用できます。
つまり、ちゃんにアイテムを送信し終わったら、それを閉じます。次に、ゴルーチン内で、チャネルが閉じられたかどうかを示す追加のパラメーターを受信オペレーターに取得します。
完全な例は次のとおりです(待機グループは、ゴルーチンが完了するまでプロセスが継続することを確認するために使用されます)。
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()
}
通常、ゴルーチンに(場合によっては)信号チャネルを渡します。そのシグナルチャネルは、ゴルーチンを停止するときに値をプッシュするために使用されます。ゴルーチンはそのチャンネルを定期的にポーリングします。信号を検出するとすぐに終了します。
quit := make(chan bool)
go func() {
for {
select {
case <- quit:
return
default:
// Do other stuff
}
}
}()
// Do stuff
// Quit goroutine
quit <- true
外部からゴルーチンを殺すことはできません。チャンネルの使用を停止するようにゴルーチンに信号を送ることはできますが、ゴルーチンに何らかのメタ管理を行うためのハンドルはありません。ゴルーチンは協力して問題を解決することを目的としているため、誤動作しているものを殺しても適切な対応とはなりません。堅牢性のために分離が必要な場合は、おそらくプロセスが必要です。
通常、ゴルーチンでチャネルを作成して停止信号を受信できます。
この例でチャネルを作成するには2つの方法があります。
チャンネル
コンテキスト。この例では、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")
}
2番目のデモでは、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")
}
私はこの答えがすでに受け入れられていることを知っていますが、2セントを投げると思ったのです。 tomb パッケージを使いたいです。これは基本的には終了したチャンネルですが、エラーを返すなどのナイスなことも行います。制御下のルーチンには、リモートの強制終了シグナルをチェックする責任があります。 Afaikは、ゴルーチンの「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
個人的に、私はゴルーチンのチャンネルで範囲を使用したいと思います:
https://play.golang.org/p/qt48vvDu8cd
Daveはこれについて素晴らしい投稿を書いています: http://dave.cheney.net/2013/04/30/curious-channels 。