Learn Concurrent Programming with Go

by James Cutajar

Concurrency doesn’t need to be confusing. Start writing concurrent code that improves performance, scales up to handle large volumes of data, and takes full advantage of modern multi-processor hardware.

Too many developers think concurrency is extremely challenging. Learn Concurrent Programming with Go is here to prove them wrong! This book uses the easy-to-grasp concurrency tools of the Go language to demonstrate principles and techniques, steadily teaching you the best practices of effective concurrency. Techniques learned in this book can be applied to other languages.

In Learn Concurrent Programming with Go you will learn how

Implement effective concurrency for more responsive, higher performing, scalable software Avoid common concurrency problems such as deadlocks and race conditions Manage concurrency using goroutines, mutexes, readers-writer locks, and more Identify concurrency patterns such as pipelining, worker pools, and message passing Discover advantages, limits, and properties of parallel computing Improve your Go coding skills with advanced multithreading topics
Concurrent programming allows multiple tasks to execute and interact simultaneously, speeding up performance and reducing user wait time. In Learn Concurrent Programming with Go, you’ll discover universal principles of concurrency, along with how to use them for a performance boost in your Go applications. Expert author James Cutajar starts with the basics of modeling concurrency in your programs, demonstrates differences between message passing and memory sharing, and even introduces advanced topics such as atomic variables and futexes.

About the technology

You can improve almost any application’s performance and responsiveness by introducing concurrency into the codebase. This book will show you how! It starts with the basics of concurrent programming and builds your skills step by step by exploring scenarios you’ll face every day as a developer. Author James Cutajar explains each aspect of concurrency in plain language using the intuitive features baked into the Go language.

About the book

Learn Concurrent Programming with Go provides a practical, hands-on introduction to creating software for modern multiprocessor systems. In it, you’ll learn how to divide larger programming tasks into independent parts that can run simultaneously. You’ll use the Go language to implement common concurrency patterns by utilizing readers-writer locks, semaphores, message passing, and memory sharing. The skills you learn will easily transfer to other languages.

What's inside

Prevent deadlocks and race conditions Go concurrency features like goroutines, mutexes, channels, and more Concurrency patterns including pipelining and worker pools
About the reader

For programmers with basic knowledge of Go or another C-style language. No experience in concurrent programming required.

About the author

James Cutajar has been programming for more than 20 years. He’s an open source contributor, blogger, tech evangelist, Udemy instructor, and author.

Genres: Go, Programming, Software, Computer Science, Technical

590 pages, Kindle Edition

Published January 30, 2024

Reviews

[Germano · Rating 5 out of 5]

I particularly appreciated this book. The title might lead one to believe that it discusses concurrency applied to Go, exposing - for example - only the part of concurrency relevant to Go, and the part of Go relevant to concurrency. And that alone could make it a good text.

What I especially liked, what satisfied me, is that instead the author speaks comprehensively about concurrency, touching on many topics exhaustively and providing useful references. Even on the Go part, he does not limit himself to the listings (so to speak) but delves deeper.

In short, it stroke me as a complete book, and very interesting for this reason. The writing seemed to me to be fluid and effective (even though English is not my mother tongue), the exposition rigorous but not heavy... I would recommend it!

[MinhTu Thomas Hoang · Rating 3 out of 5]

For Part 1 (Foundations) alone, with the chapters on mutex, condition variable and wait group, the book deserves 4 stars. These chapter offers entertaining illustrations, with hands-on demonstration of the concepts of previous chapters being building blocks for the succeeding ones.
Part 2 on Channels and Part 3 on further discussion do not go into much depth for my taste.
Overall, still a great learning resources for concurrent programming using memory-sharing primitives.

[Matvey Aksenov · Rating 2 out of 5]

I liked this one better than the previous one. The material is largely the same but the presentation is, in my opinion, more logical. It starts in 1965 with Dijkstra inventing mutexes and then continues through 1978 when Hoare writes his CSP paper. I'd love to know if any progress in concurrent programming has been made since the 1970s, but unfortunately, it's beyond the scope for this book. It includes exercises, which are very helpful if you want to properly understand the ancient technology.

[Nathan Davies · Rating 5 out of 5]

Took a couple of days to read through this book. I found the examples engaging and helpful.

I'm already pretty familiar with concurrency in Go, for those not fully up to speed with it this book is great starting point. There is enough details to get you going, and help you be productive in writing concurrent code in Go.

[Rodrigo · Rating 4 out of 5]

It has a lot of exercises and simple but effective explanations about concurrent primitives like channels and mutex. It really helped me to apply these concepts quickly in a real project.

[ju · Rating 5 out of 5]

perfect

[Maxat · Rating 4 out of 5]

solid intro to concurrent programming

[Mattia Di · Rating 5 out of 5]

Great introductory book to concurrent programming. It shows implementations of the main patterns and explains the trade-offs.
It can be read in short time, and then go back to it when facing a concurrent problem to grasp the best solution.
The choice of the Go language makes it easy to understand the code to basically anyone. I had no experience with the language and yet I had no problems understanding the code.
Definitely recommended.

[Emmanouil Chardalas · Rating 5 out of 5]

Great introductory book on concurrency through Go. Helps the reader to understand a complex topic as such with well structured examples and illustrations.