Reliable way to ensure a Go channel does not block

Question

I'm looking for a reliable to way to make sure an empty channel in Go does not block my execution. I have to iterate through a number of channels in a particular order (kind of priorities), and once I find one with items in it, read one.

Currently I do something in a similar way:

if len(myChannel) > 0 {
    // Possible issue here: length could have changed to 0 making this blocking
    elm := <- myChannel
    return elm
}

In theory this could result into too-long of waiting, while a different channel might have an item which is ready to be "served".

Any suggestions on how to improve? I could use a mutex in the channel, but it feels like there's a better solution although I'm not sure how.

Answer 1

There is a reflect.Select function that might do what you want:

package main

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

func main() {
    a, b, c := make(chan int), make(chan int), make(chan int)
    go func() {
        time.Sleep(2 * time.Second)
        a <- 1
    }()
    go func() {
        time.Sleep(time.Second)
        b <- 2
    }()
    go func() {
        time.Sleep(3 * time.Second)
        c <- 3
    }()
    for i := 0; i < 3; i++ {
        chosen, recv, ok := reflect.Select([]reflect.SelectCase{
            reflect.SelectCase{
                Dir:  reflect.SelectRecv,
                Chan: reflect.ValueOf(a),
            },
            reflect.SelectCase{
                Dir:  reflect.SelectRecv,
                Chan: reflect.ValueOf(b),
            },
            reflect.SelectCase{
                Dir:  reflect.SelectRecv,
                Chan: reflect.ValueOf(c),
            },
        })
        if ok {
            fmt.Printf("Got value %d from %d\n", recv.Interface().(int), chosen)
        }
    }
}

play.golang.org