How to "try send" to a channel, and abort if channel is full?

I have a variation of classic "producer-consumer" problem. In my program, there are 10 producers working in parallel, and their goal is to produce N products in total.

I thought about using buffered channel:

products := make([]int, 100) // In total, produce 100 products

// The producers
for i := 0; i < 10; i++ {
    go func() {
        products <- 1 // !!
    }()
}

However, it will not work:

• The goroutine does not realize that the goal is reached, channel send blocks, and the function never returns.
• if len(products) < 100 { products <- 1 } is not an atomic operation, therefore it does not help.

So is there any other approach?

products := make([]int, 100) makes a slice, not a chan. You want:

products := make(chan int, 100)

If you really want to do a non-blocking send, you can use select:

select {
case products <- 1:
default:
}

This will first try to send on products and if it is full run the default code (no-op) and continue.

The best way to do this is probably to use a quit channel and a select statement in the producer. Go guarantees that a closed channel will always register as a read without blocking.

Here's a working version on the playground

package main

import "fmt"
import "time"

func main() {
	productionChan := make(chan int)
	quit := make(chan struct{})
	for i := 0; i < 110; i++ {
		go produce(productionChan, quit)
	}

	consume(productionChan, quit)
	time.Sleep(5 * time.Second) // Just so we can observe the excess production channels quitting correctly
}

func consume(productionChan <-chan int, quit chan<- struct{}) {
	payload := make([]int, 100)

	for i := range payload {
		payload[i] = <-productionChan
	}

	close(quit)
	fmt.Println("Complete payload received, length of payload slice: ", len(payload))
}

func produce(productionChan chan<- int, quit <-chan struct{}) {
	select {
	case <-quit:
		fmt.Println("No need to produce, quitting!")
	case productionChan <- 1:
	}
}

The idea is that the single consumer goroutine iterates over a payload slice of the desired size, after that slice is filled, the loop terminates and it closes the quit channel. All producers are blocked in a select statement about whether to send, or receive from the quit channel. When the quit channel is closed, every producer launched with that quit channel will immediately exit.

This idiom should also be fairly easy to modify if you have a smaller number of producers that send multiple values each.

Disclaimer: This is not idiomatic Go in the slightest, and I don't suggest actually using this code in practice. That said...

Go recently introduced reflect.Value.TryRecv and reflect.Value.TrySend. They do exactly what you're looking for.

products := make(chan int, 100)

for i := 0; i < 10; i++ {
    go func() {
        for {
            if !reflect.ValueOf(products).TrySend(1) {
                return
            }
        }
    }()
}

See the code run on the go playground.

You can use select to try and send to a buffered channel: if you select on sending and the channel buffer is full, you'll reach the default case:

//this goroutine sends to the channel until it can't
func f(c chan int, wg *sync.WaitGroup) {

	for i := 0; ; i++ {
		select {
		case c <- i: //sent successfully
			continue
		default:
			fmt.Println("Can't send, aborting!")
			wg.Done()
			return
		}
	}
}

func main() {

	c := make(chan int, 100)
	wg := sync.WaitGroup{}
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go f(c, &wg)
	}

	wg.Wait()
	fmt.Println("Done!")

}

The drawback of this approach is that if the consumer starts consuming before you're done producing, you'll enter an infinite loop.

You can also close the channel from the consumer side causing the producers to panic, and catching this panic:

func f(c chan int) {

	defer func() {
		_ = recover()
		fmt.Println("Done!")
	}()

	for i := 0; ; i++ {
		c <- i
	}
}

func main() {

	c := make(chan int)

	for i := 0; i < 10; i++ {

		go f(c)
	}

	n := 0
	for {
		<-c
		n++
		if n > 100 {
			close(c)
			break
		}
	}

But if you just want to not produce more items than a given amount, why not spawn N goroutines, each producing 1 item? or spawning K goroutines each producing N/K items? It's better to know this in advance.