Comment arrêter une goroutine

Question

J'ai une goroutine qui appelle une méthode, et passe la valeur retournée sur un canal :

ch := make(chan int, 100)
go func(){
    for {
        ch <- do_stuff()
    }
}()

Comment arrêter une telle goroutine ?

Answer 1

Typiquement, vous passez à la goroutine un canal de signal (éventuellement séparé). Ce canal de signal est utilisé pour pousser une valeur quand vous voulez que la goroutine s'arrête. La goroutine interroge régulièrement ce canal. Dès qu'elle détecte un signal, elle s'arrête.

quit := make(chan bool)
go func() {
    for {
        select {
        case <- quit:
            return
        default:
            // Do other stuff
        }
    }
}()

// Do stuff

// Quit goroutine
quit <- true

Answer 2

EDIT : J'ai écrit cette réponse à la hâte, avant de réaliser que votre question concerne l'envoi de valeurs à un chan dans une goroutine. L'approche ci-dessous peut être utilisée soit avec un chan supplémentaire comme suggéré ci-dessus, soit en utilisant le fait que le chan que vous avez déjà est bi-directionnel, vous pouvez utiliser juste un...

Si votre goroutine existe uniquement pour traiter les éléments qui sortent du chan, vous pouvez utiliser le buildin "close" et le formulaire de réception spécial pour les canaux.

C'est-à-dire qu'une fois que vous avez fini d'envoyer des articles sur le chan, vous le fermez. Ensuite, dans votre goroutine, vous obtenez un paramètre supplémentaire à l'opérateur de réception qui indique si le canal a été fermé.

Voici un exemple complet (le groupe d'attente est utilisé pour s'assurer que le processus continue jusqu'à ce que la goroutine se termine) :

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()
}

Answer 3

On ne peut pas tuer une goroutine de l'extérieur. Vous pouvez signaler à une goroutine d'arrêter d'utiliser un canal, mais il n'y a pas de gestion des goroutines pour faire une sorte de méta-gestion. Les goroutines sont destinées à résoudre des problèmes de manière coopérative, donc en tuer une qui se comporte mal ne serait presque jamais une réponse adéquate. Si vous voulez une isolation pour la robustesse, vous voulez probablement un processus.

Answer 4

Je sais que cette réponse a déjà été acceptée, mais j'ai pensé que je devais ajouter mon grain de sel. J'aime utiliser le tombeau paquet. C'est en fait un canal de sortie amélioré, mais il fait aussi des choses sympas comme renvoyer les erreurs. La routine sous contrôle a toujours la responsabilité de vérifier les signaux d'arrêt à distance. A ce jour, il n'est pas possible d'obtenir un "id" d'une goroutine et de la tuer si elle se comporte mal (c'est-à-dire si elle est coincée dans une boucle infinie).

Voici un exemple simple que j'ai testé :

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)
}

La sortie devrait ressembler à ça :

# Loop the loop
# Loop the loop
# Loop the loop
# Loop the loop
# Death from above

Answer 5

Personnellement, j'aimerais utiliser la gamme sur un canal dans une goroutine :

https://play.golang.org/p/qt48vvDu8cd

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 %t\n", b)
        }
    }()
    c <- true
    c <- true
    close(c)
    wg.Wait()
}

Dave a écrit un excellent article à ce sujet : http://dave.cheney.net/2013/04/30/curious-channels .