cómo detener un goroutine

Normalmente, se pasa el canal de señal goroutine a (posiblemente separado). Ese canal de señal se usa para introducir un valor cuando se desea que la goroutine se detenga. Las encuestas goroutine que canalizan regularmente. Tan pronto como detecta una señal, se cierra.

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

// Do stuff

// Quit goroutine
quit <- true

No puedes matar a un goroutine desde fuera. Puedes indicar a un goroutine que deje de usar un canal, pero no hay ningún control sobre goroutines para hacer ningún tipo de gestión de meta. Las goroutinas están destinadas a resolver problemas de manera cooperativa, por lo que matar a alguien que se está portando mal casi nunca sería una respuesta adecuada. Si desea aislamiento por robustez, probablemente desee un proceso.

Sé que esta respuesta ya ha sido aceptada, pero pensé en lanzar mis 2cents. Me gusta usar el paquete tomb . Es básicamente un canal de salida suped up, pero hace cosas buenas como pasar de nuevo los errores también. La rutina bajo control todavía tiene la responsabilidad de verificar las señales de apagado remoto. Afaik no es posible obtener un " id " de un goroutine y matarlo si se está portando mal (es decir, atascado en un bucle infinito).

Aquí está un ejemplo simple que I probado:

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 salida debería ser como:

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

Personalmente, me gustaría usar range en un canal en una goroutine:

Http://play.golang.org/p/KjG8FLzPoz

Dave ha escrito un gran post sobre esto: http://dave.cheney.net/2013/04/30/curious-channels .

Generalmente, puede crear un canal y recibir una señal de stop en la rutina go.

Hay dos formas de crear un canal en este ejemplo.

1. Canal

2. Context . En el ejemplo voy a hacer una demostración context.WithCancel

La primera demo, use 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")
}

La segunda demo, use 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")
}