warum Golang Select-Anweisung wählt nicht zufällig einen Fall

Question

Dies ist ähnlich wie go tutorial select statement, aber ich habe keine Antwort von diesem Beitrag erhalten. Also habe ich hier gefragt. Danke für die Antwort.

In http://tour.golang.org/concurrency/5, scheint es "case c < - x:" ist immer bereit, was bedeutet, dass dieser Fall Select Anweisung nicht blockieren wird.

Basierend auf dem Satz "A wählen Blöcke, bis einer seiner Fälle ausgeführt werden kann, dann führt es diesen Fall aus. Es wählt einen zufällig, wenn mehrere bereit sind.", Wenn "case < -quit:" auch bereit ist, Die Select-Anweisung sollte nach dem Zufallsprinzip aus "case c < - x:" und "case < -quit:" ausgewählt werden. Aber das Programm geht immer in den "case < -quit:" Fall.

Ich änderte auch den Auswahlblock, um wie folgt zu sein. Dann in den ersten 10 Schleifen, das Programm nach dem Zufallsprinzip drucken 1-6, aber das Programm beendet einmal (die 11. Ausgabe) der Quit-Kanal hat den Wert 0.

Meine Frage ist, dass, wenn die fertigen Fälle zufällig ausgewählt sind, warum ist die elfte Auswahl immer der quit-Fall?

select { 
    case c <- 1: 
     x, y = y, x+y 
    case c <- 2: 
     x, y = y, x+y 
    case c <- 3: 
     x, y = y, x+y 
    case c <- 4: 
     x, y = y, x+y 
    case c <- 5: 
     x, y = y, x+y 
    case c <- 6: 
     x, y = y, x+y 
    case <-quit: 
     fmt.Println("quit") 
     return 
    } 

Answer 1

Auf den Case-Anweisungen, werden Sie Werte c (z c <- 1), die blockiert, bis etwas Senden c als foo := <- c off liest. Wenn etwas in quit schreibt, trifft es den Fall, in dem <-quit an ist und aus der Auswahl zurückkehrt.

Aus diesem Beispiel

package main 

import (
    "fmt" 
    "time" 
) 

func main() { 
    c := make(chan int) 
    quit := make(chan struct{}) 

    go func(q chan<- struct{}) { 
     time.Sleep(5 * time.Second) 
     q <- struct{}{} 
    }(quit) 

    go func(ch chan<- int) { 
     var x int 
     for range time.Tick(1 * time.Second) { 
      c <- x 
      x++ 
     } 
    }(c) 

    for { 
     select { 
     case foo := <-c: 
      fmt.Println("Foo", foo) 
     case bar := <-c: 
      fmt.Println("Bar", bar) 
     case <-quit: 
      fmt.Println("quit") 
      return 
     } 
    } 
} 

Sie die Werte zufällig auf Ihrem Rechner ausgedruckt sehen können, wie:

$ go run foo.go 
Bar 0 
Bar 1 
Foo 2 
Bar 3 
quit 

$ go run foo.go 
Bar 0 
Foo 1 
Bar 2 
Bar 3 
quit