How to block all goroutines except the one running

I have two (but later I'll be three) go routines that are handling incoming messages from a remote server (from a ampq channel). But because they are handling on the same data/state, I want to block all other go routines, except the one running.

I come up with a solution to use chan bool where each go routine blocks and then release it, the code is like:

package main

func a(deliveries <-chan amqp, handleDone chan bool) {
	for d := range deliveries {
		<-handleDone        // Data comes always, wait for other channels
		handleDone <- false // Block other channels

		// Do stuff with data...

		handleDone <- true // I'm done, other channels are free to do anything
	}
}

func b(deliveries <-chan amqp, handleDone chan bool) {
	for d := range deliveries {
		<-handleDone
		handleDone <- false
		// Do stuff with data...
		handleDone <- true
	}
}

func main() {
	handleDone := make(chan bool, 1)
	go a(arg1, handleDone)
	go b(arg2, handleDone)
	// go c(arg3, handleDone) , later

	handleDone <- true // kickstart
}

But for the first time each of the function will get handleDone <- true, which they will be executed. And later if I add another third function, things will get more complicated. How can block all other go routines except the running? Any other better solutions?

You want to look at the sync package.

http://golang.org/pkg/sync/

You would do this with a mutex.

If you have an incoming stream of messages and you have three goroutines listening on that stream and processing and you want to ensure that only one goroutine is running at a time, the solution is quite simple: kill off two of the goroutines.

You're spinning up concurrency and adding complexity and then trying to prevent them from running concurrently. The end result is the same as a single stream reader, but with lots of things that can go wrong.

I'm puzzled why you want this - why can't each message on deliveries be handled independently? and why are there two different functions handling those message? If each is responsible for a particular type of message, it seems like you want one deliveries receiver that dispatches to appropriate logic for the type.

But to answer your question, I don't think it's true that each function will get a true from handleDone on start. One (let's say it's a) is receiving the true sent from main; the other (b then) is getting the false sent from the first. Because you're discarding the value received, you can't tell this. And then both are running, and you're using a buffered channel (you probably want make(chan bool) instead for an unbuffered one), so confusion ensues, particularly when you add that third goroutine.

The handleDone <- false doesn't actually accomplish anything. Just treat any value on handleDone as the baton in a relay race. Once a goroutine receives this value, it can do its thing; when it's done, it should send it to the channel to hand it to the next goroutine.