chan | A Changelog CLI based on http : //keepachangelog.com/

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

Yes, it sounds like this book needs a better editor!

the channel capacity is indeed indicated as the 2nd argument to make:

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.

You can use the ItemCountAware interface for that. This interface is to implement by your domain object (which seems to be Customer in your case) and will be called at reading time by any reader that extends AbstractItemCountingItemStreamItemReader.

So if your reader is one them, you can get the item count on your items and use it as needed in your LineAggregator.

EDIT: add option when the reader does not extend AbstractItemCountingItemStreamItemReader

You can always assign the item number in a ItemReadListener#afterRead and use that in your aggregator, something like:

I haven't analyzed all of it, but definitely the modification of mapStore from multiple goroutines is unsafe:

Because match() returns null if no matches are found.

You need something like

There are several problems here:

First: if done close(jobs) is a race. Do not close the jobs channel from the worker. This will result in multiple close calls on the channel, which will panic. Close the jobs channel when you know all the jobs are submitted to the channel. That is difficult, because your goroutines also submit jobs.

Second: As you already realized, your workers that create other jobs rely on other workers reading from the channel. So the program won't event work with one worker. One way to deal with this is to submit new jobs asynchronously:

As per the comments the MQTT spec requires that:

If the ClientId represents a Client already connected to the Server then the Server MUST disconnect the existing Client [MQTT-3.1.4-2].

So if you have a connection using the ClientId go_mqtt_client and another connection comes in with the same ClientId your connection will be dropped (leading to the message you are seeing).

The broker you are using (broker.emqx.io) is a free, public broker that comes with the advice to "Never use it in production". Due to its nature you have no way of knowing who else is using it or what ClientId's they are using (and if you subscribe to # you will see all of the messages being published to the broker!).

The EMQX Demo code uses the ClientID go_mqtt_client; this means that there is a good chance that someone else is using the EMQX public broker with the same ID; in fact this is mentioned in a comment (from the "EMQ X" account) at the bottom of the page with the demo code.

Given that the demo code uses the default options it will automatically reconnect if the connection is dropped. This means you get a sequence of events something like:

1. You connect; causing the connection for user 2 (with same ClientId) to be dropped)
2. User 2 automatically reconnects causing your connection to be droped.
3. You automatically reconnect causing User 2's connection to be dropped.
4. etc...

While there is no way to be 100% certain that this is the cause of the issue you are seeing, it is certainly the most likely cause. As this is a freely available public broker this is just something you need to live with; using a random ClientId will minimise (the risk of collisions with a random 23 character ID are tiny) the chance of this happening.