Understanding Go Concurrency: Why Your Results Differ from the Book Example

Discover why your Go program's concurrency results differ from the example in "Concurrency in Go" and learn how goroutine scheduling plays a crucial role.
---
This video is based on the question https://stackoverflow.com/q/66317906/ asked by the user 'Shid' ( https://stackoverflow.com/u/6112276/ ) and on the answer https://stackoverflow.com/a/66317950/ provided by the user 'Burak Serdar' ( https://stackoverflow.com/u/11923999/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Unable to get same results than in concurrency in Go book sample code

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Go Concurrency: Why Your Results Differ from the Book Example

If you're diving into the world of concurrency in Go, you may have come across code examples that produce unexpected results when you try to run them. This often leads to confusion, especially when you're following along with a book, like Concurrency in Go: Tools and Techniques for Developers by Katherine Cox-Buday. In this post, we'll explore a common issue you might face if you're testing code from this book and provide you with a clear understanding of why your results may differ from what's expected.

The Problem

A reader of Concurrency in Go reported that the output of their code didn't match the results shown in the book. The task involved incrementing and decrementing a shared counter using goroutines and a mutex for synchronization. Despite following the code provided, their outputs varied each time they ran the program. Let's take a look at the code example and the outputs:

The Code

[[See Video to Reveal this Text or Code Snippet]]

Your Output

When you ran the code, you received the following output:

[[See Video to Reveal this Text or Code Snippet]]

Expected Output from the Book

The expected output listed in the book is quite different:

[[See Video to Reveal this Text or Code Snippet]]

Why the Differences Occur

Understanding Goroutines

The key factor to understand here is that when using goroutines in Go, there are no guarantees on the order in which they execute. The Go runtime decides the scheduling of these goroutines, leading to different possible interleavings of their execution. This means that:

Each time you run your program, the scheduling of goroutines may differ.

You may see more increments or decrements executed earlier or later than anticipated.

Valid Interleavings

The output you received is just as valid as the one presented in the book. Each run can yield various results based on how the Go runtime handles the scheduling of the goroutines. The difference is in the order and timing of their execution, which results in different outputs being printed.

Conclusion

When working with concurrency in Go, it's essential to embrace the concept of non-deterministic execution. The behavior you're observing with your program is an expected outcome when utilizing goroutines. The differences in outputs arise from the unpredictable nature of concurrency in Go, emphasizing the need to understand and design your code with these principles in mind.

By keeping this in mind, you'll be better equipped to troubleshoot issues related to concurrency and create more robust Go applications.

Keep experimenting and learning; concurrency is a nuanced topic that can significantly enhance your programming skills!