Comment arrêter une goroutine

Question

J'ai une goroutine qui appelle une méthode et transmet la valeur renvoyée sur un canal :

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

Comment puis-je arrêter une telle goroutine ?

Answer 1

En général, vous passez à la goroutine un canal de signal (éventuellement séparé). Ce canal de signal est utilisé pour y insérer une valeur lorsque vous voulez que la goroutine s'arrête. La goroutine vérifie 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:
            // Faire autre chose
        }
    }
}()

// Faire des choses

// Arrêter la 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 à l'intérieur d'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 bidirectionnel, vous pouvez utiliser juste celui-ci...

Si votre goroutine existe uniquement pour traiter les éléments qui sortent du chan, vous pouvez utiliser la fonction "close" intégrée et la forme spéciale de réception pour les canaux.

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

Voici un exemple complet (le waitgroup est utilisé pour s'assurer que le processus continue jusqu'à ce que la goroutine soit terminée) :

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

Vous ne pouvez pas tuer un goroutine depuis l'extérieur. Vous pouvez signaler à un goroutine d'arrêter en utilisant un canal, mais il n'y a aucun moyen de contrôler les goroutines pour effectuer une sorte de gestion méta. Les goroutines sont conçues pour résoudre des problèmes de manière coopérative, donc tuer une goroutine qui se comporte mal ne serait presque jamais une réponse adéquate. Si vous voulez l'isolement pour la robustesse, vous voulez probablement un processus.

Answer 4

Je sais que cette réponse a déjà été acceptée, mais je pense que je vais donner mon avis. J'aime utiliser le package tomb. C'est essentiellement un canal de sortie amélioré, mais il fait des choses sympas comme renvoyer les erreurs éventuelles également. La routine sous contrôle a toujours la responsabilité de vérifier les signaux de fin à distance. À ma connaissance, il n'est pas possible d'obtenir un "id" d'une goroutine et de la tuer si elle se comporte mal (c'est-à-dire, bloqué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() // Ne doit être appelé qu'une seule fois
  for {
    select {
    case <-proc.Tomb.Dying():
      return
    default:
      time.Sleep(300 * time.Millisecond)
      fmt.Println("Boucle infinie")
    }
  }
}

func main() {
  proc := &Proc{}
  go proc.Exec()
  time.Sleep(1 * time.Second)
  proc.Tomb.Kill(fmt.Errorf("La mort venue d'en haut"))
  err := proc.Tomb.Wait() // Renvoie l'erreur qui a tué le processus
  fmt.Println(err)
}

La sortie devrait ressembler à :

# Boucle infinie
# Boucle infinie
# Boucle infinie
# Boucle infinie
# La mort venue d'en haut

Answer 5

Personnellement, j'aimerais utiliser une plage 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("Bonjour %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.