Ausbrechen einer Select-Anweisung, wenn alle Kanäle geschlossen sind

Question

Ich habe zwei Göroutinen, die unabhängig voneinander Daten produzieren, die sie jeweils an einen Kanal senden. In meiner Haupt-Routine möchte ich jeden dieser Ausgänge konsumieren, so wie sie kommen, aber die Reihenfolge, in der sie eingehen, interessiert mich nicht. Jeder Kanal schließt sich selbst, wenn er seine Ausgabe erschöpft hat. Während die select-Anweisung die einfachste Syntax ist, um Eingaben unabhängig voneinander zu konsumieren, habe ich keinen übersichtlichen Weg gesehen, um jeden einzelnen zu durchlaufen, bis beide Kanäle geschlossen sind.

for { 
    select { 
    case p, ok := <-mins: 
     if ok { 
      fmt.Println("Min:", p) //consume output 
     } 
    case p, ok := <-maxs: 
     if ok { 
      fmt.Println("Max:", p) //consume output 
     } 
    //default: //can't guarantee this won't happen while channels are open 
    // break //ideally I would leave the infinite loop 
       //only when both channels are done 
    } 
} 

das Beste, was ich denken kann, zu tun, ist die folgende (nur skizziert, haben Fehler kompilieren können):

for { 
    minDone, maxDone := false, false 
    select { 
    case p, ok := <-mins: 
     if ok { 
      fmt.Println("Min:", p) //consume output 
     } else { 
      minDone = true 
     } 
    case p, ok := <-maxs: 
     if ok { 
      fmt.Println("Max:", p) //consume output 
     } else { 
      maxDone = true 
     } 
    } 
    if (minDone && maxDone) {break} 
} 

aber das sieht aus wie wäre es nicht haltbar, wenn man mit mehr arbeiten als zwei oder drei Kanäle. Die einzige andere Methode, die ich kenne, besteht darin, einen Timout-Fall in der switch-Anweisung zu verwenden, der entweder klein genug ist, um ein frühes Verlassen zu riskieren, oder zu viel Ausfallzeit in die letzte Schleife injiziert. Gibt es eine bessere Möglichkeit, Kanäle zu testen, die sich in einer SELECT-Anweisung befinden?

Answer 1

Ihre Beispiellösung würde nicht gut funktionieren. Sobald einer von ihnen geschlossen wurde, war er immer sofort für die Kommunikation verfügbar. Das bedeutet, dass Ihre Goroutine niemals nachgibt und andere Kanäle möglicherweise nie bereit sind. Sie würden effektiv in eine Endlosschleife eintreten. Ich postete ein Beispiel, um den Effekt hier zu veranschaulichen: http://play.golang.org/p/rOjdvnji49

Also, wie würde ich dieses Problem lösen? Ein Nullkanal ist niemals für die Kommunikation bereit. Jedes Mal, wenn Sie auf einen geschlossenen Kanal stoßen, können Sie diesen Kanal auf Null stellen und sicherstellen, dass er nie wieder ausgewählt wird. Fahrbare Beispiel hier: http://play.golang.org/p/8lkV_Hffyj

for { 
    select { 
    case x, ok := <-ch: 
     fmt.Println("ch1", x, ok) 
     if !ok { 
      ch = nil 
     } 
    case x, ok := <-ch2: 
     fmt.Println("ch2", x, ok) 
     if !ok { 
      ch2 = nil 
     } 
    } 

    if ch == nil && ch2 == nil { 
     break 
    } 
} 

Was ist Angst davor immer unhandlich, ich glaube nicht, es wird. Es ist sehr selten, dass Kanäle zu viele Orte gleichzeitig haben. Dies würde so selten vorkommen, dass mein erster Vorschlag darin besteht, mich damit zu befassen. Eine lange if-Anweisung, die 10 Kanäle mit Null vergleicht, ist nicht der schlechteste Teil, wenn man versucht, mit 10 Kanälen in einer Auswahl umzugehen.

Answer 2

Schließen ist in einigen Situationen schön, aber nicht alle. Ich würde es hier nicht benutzen. Stattdessen würde ich nur getan Kanal verwenden:

for n := 2; n > 0; { 
    select { 
    case p := <-mins: 
     fmt.Println("Min:", p) //consume output 
    case p := <-maxs: 
     fmt.Println("Max:", p) //consume output 
    case <-done: 
     n-- 
    } 
} 

komplettes Arbeitsbeispiel auf dem Spielplatz: http://play.golang.org/p/Cqd3lg435y

Answer 3

Warum nicht goroutines verwenden? Wenn deine Kanäle geschlossen werden, verwandelt sich das Ganze in eine einfache Bereichsschleife.

func foo(c chan whatever, prefix s) { 
     for v := range c { 
       fmt.Println(prefix, v) 
     } 
} 

// ... 

go foo(mins, "Min:") 
go foo(maxs, "Max:") 

Answer 4

Ich schrieb ein Paket, das eine Funktion zur Lösung dieses Problems bietet (unter mehreren anderen):

https://github.com/eapache/channels

https://godoc.org/github.com/eapache/channels

Schauen Sie sich die Multiplex Funktion. Er verwendet Reflektion, um auf eine beliebige Anzahl von Eingangskanälen zu skalieren.