Checking if a channel has a ready-to-read value, using Go

How do I check whether a channel has a value for me to read?

I don't want to block when reading a channel. I want to see whether it has a value. If it does have one, I'll read it. If it doesn't have one (yet), I'll do something else and check back again later.

The only non-blocking operation I know of to read from a channel is inside a select block having a default case :

	select {
	case x, ok := <-ch:
		if ok {
			fmt.Printf("Value %d was read.\n", x)
		} else {
			fmt.Println("Channel closed!")
		}
	default:
		fmt.Println("No value ready, moving on.")
	}

Please try the non-blocking here

Note about previous answers: the receive operator itself is now a blocking operation, as of Go 1.0.3 . The spec has been modified. Please try the blocking here (deadlock)

Unfortunately, the previous answers are incorrect. The spec clearly says that you CAN use channels this way using len() function, but only if you specified the channel capacity - the buffer length for a channel while making it. If you omitted a channel capacity while making it - the channel operations are always blocking.

If you're doing this often then it's probably not a great design and you might be better off spawning another goroutine to do whatever work you're planning to do when there isn't anything to read from the channel. The synchronous/blocking nature of Go's channels make code easier to read and reason about while the scheduler and cheap goroutines means that async calls are unnecessary since waiting goroutines take up very little resources.

You don't, at least not for synchronous (unbuffered) channels. There is no way to tell if a value is waiting without asking to take the value from the channel.

For buffered channels, you technically can use the len function to do what you describe, but you really, really shouldn't. Your technique is invalid.

The reason is that it represents a race condition. Given channel ch, your goroutine might see that len(ch) > 0 and conclude that there is a value waiting. It cannot conclude however, that it can read from the channel without blocking--another goroutine might empty the channel between the time you check len and the time your receive operation runs.

For the purpose you described, use select with a default case as Ripounet showed.

WARNING: This is no longer accurate, see the answer below.

<s>From the docs:

> If a receive expression is used in an
> assignment or initialization of the
> form
>
> x, ok = <-ch
> x, ok := <-ch
> var x, ok = <-ch
>
> the receive operation becomes
> non-blocking. If the operation can
> proceed, the boolean variable ok will
> be set to true and the value stored in
> x; otherwise ok is set to false and x
> is set to the zero value for its type
</s>

In most cases relying on such information is a really bad design choice. Not even saying about how it's dirty in it's implementation.

So, do not implement the following steps to detect if channel is ready for read at runtime:

• define hchan waitq sudog structs as defined here - https://golang.org/src/runtime/chan.go
• use "unsafe" package to cast channel to pointer to hchan struct
• read sendq field of this struct to get listeners
• read first sudog and read msg field from there.
• cast msg to the appropriate type for the channels using "reflect" and "unsafe"