Как слушать N каналов в Go: динамический select для произвольного числа каналов?

Динамический select через рефлексию

Go предоставляет пакет reflect с функцией reflect.Select, которая позволяет реализовать динамический select для любого количества каналов. Это официальный способ решения вашей задачи.

Вот базовый пример:

package main

import (
    "fmt"
    "reflect"
    "time"
)

func main() {
    // Создаём произвольное количество каналов
    ch1 := make(chan int, 1)
    ch2 := make(chan int, 1)
    ch3 := make(chan int, 1)

    // Отправляем тестовые данные
    ch1 <- 10
    ch2 <- 20
    ch3 <- 30

    // Собираем каналы в срез
    channels := []chan int{ch1, ch2, ch3}

    // Преобразуем в []reflect.SelectCase
    cases := make([]reflect.SelectCase, len(channels))
    for i, ch := range channels {
        cases[i] = reflect.SelectCase{
            Dir:  reflect.SelectRecv,
            Chan: reflect.ValueOf(ch),
        }
    }

    // Динамический select
    chosen, value, ok := reflect.Select(cases)
    if ok {
        fmt.Printf("Канал #%d: %d\n", chosen, value.Int())
    }
}

Продвинутый пример с циклом

Чаще всего нужно обрабатывать сообщения в цикле, пока все каналы не будут закрыты:

func dynamicSelect(channels []chan int) {
    cases := make([]reflect.SelectCase, len(channels))
    for i, ch := range channels {
        cases[i] = reflect.SelectCase{
            Dir:  reflect.SelectRecv,
            Chan: reflect.ValueOf(ch),
        }
    }

    // Счётчик закрытых каналов
    closed := 0
    total := len(cases)

    for closed < total {
        chosen, value, ok := reflect.Select(cases)
        if ok {
            fmt.Printf("Получено %d из канала #%d\n", value.Int(), chosen)
        } else {
            // Канал закрыт — заменяем его на nil-канал, чтобы не блокироваться
            cases[chosen].Chan = reflect.ValueOf(nil)
            closed++
            fmt.Printf("Канал #%d закрыт\n", chosen)
        }
    }
    fmt.Println("Все каналы закрыты")
}

Важные моменты

• Производительность: reflect.Select медленнее статического select (~10-50 раз). Если у вас до 10 каналов и невысокая частота сообщений — это нормально.
• Закрытие каналов: Когда канал закрывается, ok становится false. Рекомендуется заменять закрытый канал на nil, чтобы он больше не участвовал в select.
• Динамическое добавление: Вы можете пересоздавать срез cases при добавлении/удалении каналов.

Альтернатива: паттерн "fan-in" с горутиной-мультиплексором

Если количество каналов фиксировано на время работы, можно создать одну горутину, которая слушает все каналы через отдельные горутины-прокладки:

func fanIn(channels ...<-chan int) <-chan int {
    out := make(chan int)
    for _, ch := range channels {
        go func(c <-chan int) {
            for v := range c {
                out <- v
            }
        }(ch)
    }
    return out
}

// Использование:
// merged := fanIn(ch1, ch2, ch3)
// for msg := range merged { ... }

Этот подход более производительный, но требует дополнительных горутин и не поддерживает динамическое изменение набора каналов без перезапуска.

Рекомендация

Для большинства практических задач (до 50-100 каналов) reflect.Select работает вполне приемлемо. Если производительность критична — используйте fan-in с горутинами. Но помните: "преждевременная оптимизация — корень всех зол".

func bridge(ctx context.Context, channels ...<-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, ch := range channels {
            go func(c <-chan int) {
                for {
                    select {
                    case <-ctx.Done():
                        return
                    case v, ok := <-c:
                        if !ok {
                            return
                        }
                        select {
                        case out <- v:
                        case <-ctx.Done():
                            return
                        }
                    }
                }
            }(ch)
        }
        // Ждём завершения контекста
        <-ctx.Done()
    }()
    return out
}