Priorität in der Go select-Anweisung Abhilfe

die Sprache unterstützt das nativ, und es ist keine Problemumgehung erforderlich. Es ist ganz einfach: der quit-Kanal sollte nur sichtbar sein, um den Produzenten. Beim beenden der Hersteller schließt den Kanal. Nur, wenn der channel leer ist und geschlossen, hat der Verbraucher zu beenden. Möglich wird dies durch Lesen aus dem Kanal wie folgt:

v, ok := <-c

dies ok auf einen booleschen Wert, der angibt, ob oder nicht der Wert v war tatsächlich Lesen Sie den Kanal (ok == true), oder wenn v wurde eingestellt, um den null-Wert des Typs verarbeitet der Kanal c weil c ist geschlossen und leer (ok == false). Wenn der Kanal geschlossen ist und nicht leer ist, v wird ein Gültiger Wert ok wird true. Wenn der Kanal ist geschlossen und leer, v wird der null-Wert des Typs verarbeitet der Kanal c, und ok wird false, was darauf hinweist, dass v ist nutzlos.

Hier ist ein Beispiel zur Verdeutlichung:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

var (
    produced  = 0
    processed = 0
)

func produceEndlessly(out chan int, quit chan bool) {
    defer close(out)
    for {
        select {
        case <-quit:
            fmt.Println("RECV QUIT")
            return
        default:
            out <- rand.Int()
            time.Sleep(time.Duration(rand.Int63n(5e6)))
            produced++
        }
    }
}

func quitRandomly(quit chan bool) {
    d := time.Duration(rand.Int63n(5e9))
    fmt.Println("SLEEP", d)
    time.Sleep(d)
    fmt.Println("SEND QUIT")
    quit <- true
}

func main() {
    vals, quit := make(chan int, 10), make(chan bool)
    go produceEndlessly(vals, quit)
    go quitRandomly(quit)
    for {
        x, ok := <-vals
        if !ok {
            break
        }
        fmt.Println(x)
        processed++
        time.Sleep(time.Duration(rand.Int63n(5e8)))
    }
    fmt.Println("Produced:", produced)
    fmt.Println("Processed:", processed)
}

dies ist dokumentiert in der "Receive-Operator" - Abschnitt der go-spec: http://golang.org/ref/spec#Receive_operator

Erstellt habe ich eine ziemlich einfache Lösung. Es tut, was ich will, aber wenn jemand eine bessere Lösung haben, bitte lassen Sie mich wissen:

exiting := false
for !exiting || len(out)>0 {
    select {
        case i := <-out:
            fmt.Printf("Value: %d\n", i)
        case <-exit:
            exiting = true
            fmt.Println("Exiting")
    }
}

Statt beenden auf Empfang, I-flag eine Ausfahrt, verlassen habe ich einmal gemacht, sicher ist nichts mehr übrig in chan out.

Ich denke, dass Sonia ' s Antwort ist falsch.Dies ist meine Lösung,etwas erschweren.

package main

import "fmt"

func sender(out chan int, exit chan bool){
    for i := 1; i <= 10; i++ {
        out <- i
    } 
    exit <- true
}

func main(){
    out := make(chan int, 10)
    exit := make(chan bool)

    go sender(out, exit)

    L:
    for {
        select {
            case i := <-out:
                fmt.Printf("Value: %d\n", i)
            case <-exit:
                for{
                    select{
                    case i:=<-out:
                        fmt.Printf("Value: %d\n", i)
                    default:
                        fmt.Println("Exiting")
                        break L
                    }
                }
                fmt.Println("Exiting")
                break L
        }
    }
    fmt.Println("Did we get all 10? Yes!")
}

Hier ist eine weitere option.

Consumer-Code:

  go func() {
    stop := false
    for {
      select {
      case item, _ := <-r.queue:
        doWork(item)
      case <-r.stopping:
        stop = true
      }
      if stop && len(r.queue) == 0 {
        break
      }
    }
  }()