как выбрать для ввода динамический список каналов в Go? - PullRequest
Новая
       14

как выбрать для ввода динамический список каналов в Go?

8 голосов
/ 19 ноября 2010

Go имеет механизм блокировки чтения одного из нескольких каналов, оператор select . Так что вы можете сказать 

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

будет блокироваться, пока мы не получим входной сигнал от любого из этих двух каналов. Очень хорошо.

Но для этого необходимо указать в исходном коде, сколько каналов я хочу опрашивать. Что если у меня есть фрагмент или массив каналов, и я хочу заблокировать их, пока не получу вход по любому из них?

Ответы [ 4 ]

6 голосов
/ 24 июля 2013

Начиная с go1.1, существует правильный API для динамического выбора наборов.

Вот полный и полезный пример: 

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)
    }
}

Вы можете поиграть с ним в интерактивном режиме на детская площадка

4 голосов
/ 19 ноября 2010 
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)
}

печатает [0 1][1 2] (или может [1 2][0 1]).

4 голосов
/ 19 ноября 2010

Просто мысль, но вы можете использовать шаблон мультиплексирования, когда вы создаете программу с 2 каналами, которые блокируют оба и отправляют вывод на новый канал. Затем вы можете просто построить из них дерево динамически из своего списка, который объединяет все в один канал, который вы затем читаете.

0 голосов
/ 23 июля 2013

Возможно, что-то подобное может подойти? 

// 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
}
...