Create channels with extra flags in an idiomatic way

TL;DR I want to have the functionality where a channel has two extra fields that tell the producer whether it is allowed to send to the channel and if so tell the producer what value the consumer expects. Although I know how to do it with shared memory, I believe that this approach goes against Go's ideology of "Do not communicate by sharing memory; instead, share memory by communicating."

Context:

I wish to have a server S that runs (besides others) three goroutines:

1. Listener that just receives UDP packets and sends them to the demultplexer.
2. Demultiplexer that takes network packets and based on some data sends it into one of several channels
3. Processing task which listens to one specific channel and processes data received on that channel.

To check whether some devices on the network are still alive, the processing task will periodically send out nonces over the network and then wait for k seconds. In those k seconds, other participants of my protocol that received the nonce will send a reply containing (besides other information) the nonce. The demultiplexer will receive the packets from the listener, parse them and send them to the processing_channel. After the k seconds elapsed, the processing task processes the messages pushed onto the processing_channel by the demultiplexer.

I want the demultiplexer to not just blindly send any response (of the correct type) it received onto the the processing_channel, but to instead check whether the processing task is currently even expecting any messages and if so which nonce value it expects. I made this design decision in order to drop unwanted packets a soon as possible.

My approach:

In other languages, I would have a class with the following fields (in pseudocode):

class ActivatedChannel{
    boolean    flag_expecting_nonce;
    int        expected_nonce;
    LinkedList chan;
}

The demultiplexer would then upon receiving a packet of the correct type simply acquire the lock for the ActivatedChannel processing_channel object, check whether the flag is set and the nonce matches, and if so add the message to the LinkedList chan!

Problem:

This approach makes use of locks and shared memory, which does not align with Golang's "Do not communicate by sharing memory; instead, share memory by communicating" mantra. Hence, I would like to know... :

1. ... whether my approach is "bad" regarding Go in the sense that it relies on shared memory.
2. ... how to achieve the outlined result in a more Go-like way.

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:

type ChannelState struct {
    ChannelId        string // unique identifier for processing channel
	IsExpectingNonce bool
	ExpectedNonce    int
}

In this approach, there is no lock used.