Wie wählt man eine Eingabe für eine dynamische Liste von Kanälen in Go?

Question

Go hat einen Mechanismus, um einen blockierenden Lesevorgang von einem von mehreren Kanälen auszuführen, die select Anweisung. So können Sie sagen

select { 
    case <- c1: 
    case <- c2: 
} 

wird blockiert, bis wir Eingang von einem dieser beiden Kanäle erhalten. Sehr schön.

Aber das erfordert, dass ich im Quellcode angeben, wie viele Kanäle ich abfragen möchte. Was ist, wenn ich eine Scheibe oder ein Array von Kanälen habe und blockieren möchte, bis ich eine Eingabe von ihnen bekomme?

Answer 1

Nur ein Gedanke, aber Sie könnten ein Multiplexing-Muster verwenden, wo Sie eine Goroutine mit 2 Kanälen spawnen, die auf beiden blockiert und die Ausgabe an einen neuen Kanal sendet. Dann können Sie einfach einen Baum dynamisch von Ihrer Liste aufbauen, der alles auf einen Kanal herunterleitet, den Sie dann weiterlesen.

Answer 2

package main 

import "fmt" 

func main() { 
    c1 := make(chan int) 
    c2 := make(chan int) 

    go func() { c1 <- 1 }() 
    go func() { c2 <- 2 }() 

    cs := []chan int{c1, c2} 
    cm := make(chan [2]int) 

    for idx, c := range(cs) { 
     go func(idx int, c chan int) { 
      cm <- [2]int{idx, <-c} 
     }(idx, c) 
    } 

    fmt.Print(<-cm) 
    fmt.Print(<-cm) 
} 

druckt [0 1][1 2] (oder vielleicht [1 2][0 1]).

Answer 3

Vielleicht kann so etwas zutreffen?

// multiplex takes a slice of chan ints and returns a channel 
// that multiplexes between all of them. 
func multiplex(chs []<-chan int) <-chan int { 
    c := make(chan int) 
    d := make(chan bool) 
    for _, ch := range chs { 
     go func(ch <-chan int) { 
      for r := range ch { 
       c <- r 
      } 
      d <- true 
     }(ch) 
    } 
    go func() { 
     for i := 0; i < len(chs); i++ { 
      <-d 
     } 
     close(c) 
    }() 
    return c 
} 

Answer 4

Seit go1.1 gibt es eine richtige API, um ausgewählte Sätze dynamisch auszuführen.

Hier ist ein komplettes und benutzbar Beispiel:

package main 

import (
    "log" 
    "reflect" 
) 

func sendToAny(ob int, chs []chan int) int { 
    set := []reflect.SelectCase{} 
    for _, ch := range chs { 
     set = append(set, reflect.SelectCase{ 
      Dir: reflect.SelectSend, 
      Chan: reflect.ValueOf(ch), 
      Send: reflect.ValueOf(ob), 
     }) 
    } 
    to, _, _ := reflect.Select(set) 
    return to 
} 

func recvFromAny(chs []chan int) (val int, from int) { 
    set := []reflect.SelectCase{} 
    for _, ch := range chs { 
     set = append(set, reflect.SelectCase{ 
      Dir: reflect.SelectRecv, 
      Chan: reflect.ValueOf(ch), 
     }) 
    } 
    from, valValue, _ := reflect.Select(set) 
    val = valValue.Interface().(int) 
    return 
} 

func main() { 
    channels := []chan int{} 
    for i := 0; i < 5; i++ { 
     channels = append(channels, make(chan int)) 
    } 

    go func() { 
     for i := 0; i < 10; i++ { 
      x := sendToAny(i, channels) 
      log.Printf("Sent %v to ch%v", i, x) 
     } 
    }() 

    for i := 0; i < 10; i++ { 
     v, x := recvFromAny(channels) 
     log.Printf("Received %v from ch%v", v, x) 
    } 
} 

Sie damit interaktiv spielen, um können the playground