goroutines | provides utilities to perform common tasks on goroutines

So is there any way to acquire those locks only if all of them are available?

No. Not with standard library mutex at least. There is no way to "check" if a lock is available, or "try" acquiring a lock. Every call of Lock() will block until locking is successful.

The implementation of mutex relies on atomic operations which only act on a single value at once. In order to achieve what you describe, you'd need some kind of "meta locking" where execution of the lock and unlock methods are themselves protected by a lock, but this probably isn't necessary just to have correct and safe locking in your program:

Penelope Stevens' comment explains correctly: As long as the order of acquisition is consistent between different goroutines, you won't get deadlocks, even for arbitrary subsets of the locks, if each goroutine eventually releases the locks it acquires.

If the structure of your program provides some obvious locking order, then use that. If not, you can create your own special mutex type that has intrinsic ordering.

Looking at your code, two things can cause a deadlock:

• errg.Wait() blocks the execution of the main goroutine until all initialized goroutines are finished. However, each goroutine is blocked when trying to write to mapChan, because you never get to read from it (because it is below the errg.Wait()).
• You never read from sliceChan, so that is a potential deadlock right there.

Here is the link to the modified Playground code, but most of the changes are in the main function.

I have found tomb to be useful for this. Below is a stripped-down non-working example that shows the gist, without handling things like variable encapsulation in the loop. It should give you the idea, but I'm happy to clarify on any points.

The mongo.Client manages an internal connection pool. You do not have to worry about that. mongo.Client is safe for concurrent use.

If you want to limit the internal pool, you may do so at connection using ClientOptions. For example:

With the wg waitgroup (as coded in your current group) : when the subscribe function returns, you know that the waiting goroutine has at least started its execution.

So when your main function reaches button.Clicked.Broadcast(), there's a good chance the two goroutines are actually waiting on their button.Clicked.Wait() call.

Without the wg, you have no guarantee that the goroutines have even started, and your code may call button.Clicked.Broadcast() too soon.

Note that your use of wg merely makes it less probable for the deadlock to happen, but it won't prevent it in all cases.

Try compiling your binary with -race, and run it in a loop (e.g from bash : for i in {1..100}; do ./myprogram; done), I think you will see that the same problem happens sometimes.

Before diving into your solution and its issues, let me recommend again another Broker approach presented in this answer: How to broadcast message using channel

Now on to your solution.

Whenever you launch a goroutine, always think of how it will end and make sure it does if the goroutine is not ought to run for the lifetime of your app.

Yes, the approach described by you doesn't align with Golang's Idiomatic way of implementation. And you have rightly pointed out that in the above approach you are communicating by sharing memory.

To achieve this in Go's Idiomatic way, one of the approaches could be that your Demultiplexer "remembers" all the processing_channels that are expecting nonce and the corresponding type of the nonce. Whenever a processing_channels is ready to receive a reply, it sends a signal to the Demultiplexe saying that it is expecting a reply.

Since Demultiplexer is at the center of all the communication it can maintain a mapping between a processing_channel & the corresponding nonce it expects. It can also maintain a "registry" of all the processing_channels which are expecting a reply.

In this approach, we are Sharing memory by communicating

For communicating that a processing_channel is expecting a reply, the following struct can be used:

The statement channels := make([]chan int, 5) is allocating a array with nil channels which

• Blocks receiving <- channel from channel
• Blocks sending channel <- value into channel
• panics on closing close(channel)

So you have to initialize each channel individually to recive integer values.

You should init the channels in the channels array before using those.

The goroutine executes the default branch twice and blocks on send to c. The <-ctx.Done() case is not executed because the goroutine is stuck in the default branch.

Fix the problem by sending from the select case instead of the branch statements.