What do you think?
Rate this book
Concurrency in Go: Tools and Techniques for Developers
Concurrency can be notoriously difficult to get right, but fortunately, the Go open source programming language makes working with concurrency tractable and even easy. If youâ??re a developer familiar with Go, this practical book demonstrates best practices and patterns to help you incorporate concurrency into your systems. Author Katherine Cox-Buday takes you step-by-step through the process. Youâ??ll understand how Go chooses to model concurrency, what issues arise from this model, and how you can compose primitives within this model to solve problems. Learn the skills and tooling you need to confidently write and implement concurrent systems of any size.
236 pages, Paperback
Published September 5, 2017
189 people are currently reading
560 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 36 reviews
March 18, 2018
For the most part, this book does a decent job of picking up where the Go Programming Language left off, going deeper into the specific topic.
There are a few clear negatives:
A concerning number of bad editorial mistakes. While I didn't notice any fatal errors, it's hard to trust that the book gets some of the trickier topics correct if it can't get simple things right.
There were some very poorly written sections (e.g. the bit on queuing theory) and some that seemed mostly irrelevant and odd (e.g. the very heavy-weight approach to error details).
There were also some sections that I enjoyed and learned quite a bit from, such as rate limiting and how the runtime schedules goroutines.
Ultimately, I think the book failed to demonstrate a convincing pattern for idiomatic use of channels. This is particularly evident on page 111 where the author advocates writing libraries of common pipeline patterns using interface{} while acknowledging that this is unidiomatic go. It's clear why: the example code, even with factored out bits, is very intricate and mixes concurrency handling quite closely with business logic, which doesn't feel like a very scalable model for most development tasks.
There are a few clear negatives:
A concerning number of bad editorial mistakes. While I didn't notice any fatal errors, it's hard to trust that the book gets some of the trickier topics correct if it can't get simple things right.
There were some very poorly written sections (e.g. the bit on queuing theory) and some that seemed mostly irrelevant and odd (e.g. the very heavy-weight approach to error details).
There were also some sections that I enjoyed and learned quite a bit from, such as rate limiting and how the runtime schedules goroutines.
Ultimately, I think the book failed to demonstrate a convincing pattern for idiomatic use of channels. This is particularly evident on page 111 where the author advocates writing libraries of common pipeline patterns using interface{} while acknowledging that this is unidiomatic go. It's clear why: the example code, even with factored out bits, is very intricate and mixes concurrency handling quite closely with business logic, which doesn't feel like a very scalable model for most development tasks.
May 25, 2020
I have mixed feelings about this book. Some parts I loved, some parts I did not like at all.
Starting with the good, I think the book has a fantastic introduction to concurrency in Go. I absolutely loved how in the first, second and last chapters, it explains from a very high level how the Go runtime works, its scheduling algorithm and where do the Goroutines fit into the whole picture. It narrates a clear picture and provides just enough details to make it a sufficient read for most readers. For those who wish to read further, it provides more than enough leads to continue reading online. All in all, loved this part.
On the other hand, I found that its take on the language's building blocks and patterns was very underwhelming. Too many examples and an overall a very slow read. Also, I was expecting some insights into the WHYs rather than the HOWs, but it looks like the author wasn't. In a nutshell, I didn't like the middle part of the book.
TLDR; I would recommend this book. I think it has enough good parts to overweigh the parts I didn't enjoy as much. I think it's a fantastic introduction to Go Concurrency, and a fairly light read, considering that concurrency never is.
Starting with the good, I think the book has a fantastic introduction to concurrency in Go. I absolutely loved how in the first, second and last chapters, it explains from a very high level how the Go runtime works, its scheduling algorithm and where do the Goroutines fit into the whole picture. It narrates a clear picture and provides just enough details to make it a sufficient read for most readers. For those who wish to read further, it provides more than enough leads to continue reading online. All in all, loved this part.
On the other hand, I found that its take on the language's building blocks and patterns was very underwhelming. Too many examples and an overall a very slow read. Also, I was expecting some insights into the WHYs rather than the HOWs, but it looks like the author wasn't. In a nutshell, I didn't like the middle part of the book.
TLDR; I would recommend this book. I think it has enough good parts to overweigh the parts I didn't enjoy as much. I think it's a fantastic introduction to Go Concurrency, and a fairly light read, considering that concurrency never is.
January 3, 2019
I have expected too much from this book, as the reviews I've read were all quite positive. Sadly the book was a disappointment simply due to spending too much time on simple coding topics (ex. API rate limiting examples) or just copy-pasting almost identical code excerpts (ex. pipeline examples and monads).
The useful content here was less than 20% of the overall book contents and the examples were frequently dealing with the same problems over and over, while being badly formatted up to the point of a few dozen lines of code spanning several pages. I would say that an experienced coder (not necessarily in Go, but any other language) can safely skip this without missing anything significant.
Final verdict: Skip it.
The useful content here was less than 20% of the overall book contents and the examples were frequently dealing with the same problems over and over, while being badly formatted up to the point of a few dozen lines of code spanning several pages. I would say that an experienced coder (not necessarily in Go, but any other language) can safely skip this without missing anything significant.
Final verdict: Skip it.
December 25, 2019
Great read with lots of code examples. The solutions in this book will be a great help in my day to day as a Go developer.
September 10, 2020
An awesome book to use Go concurrency with understanding.
December 15, 2021
Perhaps one of the best books on Go I have read so far. There is little we can call unique in Go but the currency model. It is not like it is particularly novel, but there was a time when not many programming languages offered what Go has had for a while. Although these days, more languages are catching up with the model and offering similar or even more exciting alternatives. So, investing time in learning and gaining an appreciation for the Go concurrency model is something that I found fascinating and very practical. I'm sure I can use this knowledge to understand what other modern programming languages have started to offer as well. This book was wonderful to achieve that goal. The author extensively covers many functional patterns of Go concurrency using goroutines and channels and offers many valuable examples. I immediately applied some of this knowledge to my work, translating many of these concepts into practical applications. So, I can attest the book is instrumental, practical, and fascinating. It is something that I cannot say of every Go book, so I must highlight that, so far, this is my favorite.
October 11, 2021
Very light and introductory read. Touches a little bit of everything, from queuing theory to critical sections and work stealing. I expected something deeper and more practical (channel of channels I'm looking at you).
March 3, 2018
Gazillion industry paperbacks already cover syntax, semantics and patterns of Go programming language. This is perhaps the first book that went under the hood of the Go internals. An example - the author meticulously constructed benchmark to underline several orders of magnitude improvement from threading concurrency model (hardware/OS context switch) to Coroutine/CSP concurrency model in Go (software context switch). An enjoyable read, especially for engineers who relish on understanding "why" beyond "how".
March 13, 2021
The book seemed to me both not enough theoretical and not enough practical. By theoretical, I mean deep explanation of go concepts. The book is not enough practical because the code samples can not be taken as is to use in any application. However the examples are extraordinary primarily because of their style. I suppose the book can be useful in some circumstances but I think one should choose another golang book for learning.
September 4, 2021
I approached this book as an experienced programmer, but one with no more experience with go than a weekend reading the "go-by-example" examples. I would not recommend any less experience with Go than that, as this has no "Golang Refresher" chapter. Which is nice, because it shouldn't be an expectation that every Language book include a primer for the uninitiated. Get initiated then come back.
That said, even inexperienced as I was in Go, I found this to be a massively useful tome. If you're familiar with C-heritage languages, most of Go is pretty easy to pick up, the trickiest part (and indeed one of Go's biggest features) is channels and goroutines. This book is just a treatise on how to use those well. So, if you spend two hours learning all of the other primitives of Go except for goroutines and channels, you can safely trust Katherine to teach you all you need to know to start using them safely and with confidence.
The topics and examples are no-nonsense, and get to the point without rambling or repetition. Cox-Buday respects the reader's intelligence, and is able to provide concise explanation and examples that are still accessible and not obscure. She does teach a specific design pattern that is repeated in every example until it becomes rote for the reader, but this is important as if you can and do follow this pattern, you will avoid pretty much all of the pitfalls of concurrent programming in Go. All of the pain points that everyone is always complaining about just "go away." Granted, you will not always be able to use these patterns, but they are generic enough to fit most usecases and almost all entry-level situations.
This book took me from Go virgin to having a working parallel microservice API in a week. That includes the time debugging. Though this book didn't discuss debugging multi-threaded programs, which would have been a good addition (but that's also not something you can just "splash" into a quick chapter), it turns out following the patterns put forth by Cox-Buday makes a fairly debuggable program (and I think Golang itself lends itself to programs easier to debug in a multi-threaded context, mostly by simplifying the multi-threaded programming model into a fairly clean abstraction).
If you're developing any sort of multi-threaded or network application, and Golang is even an option, it's worth doing a Go crash course and picking up this book. As someone who has done multi-threaded dev work in C and python, it absolutely would have saved me time to learn a new language and read this book.
And if you use Go, and you find channels or goroutines elusive, frustrating, buggy, or intimidating (in fact, if you still have negative things to say about them at all), I'd recommend picking up this book and seeing how you feel afterward.
That said, even inexperienced as I was in Go, I found this to be a massively useful tome. If you're familiar with C-heritage languages, most of Go is pretty easy to pick up, the trickiest part (and indeed one of Go's biggest features) is channels and goroutines. This book is just a treatise on how to use those well. So, if you spend two hours learning all of the other primitives of Go except for goroutines and channels, you can safely trust Katherine to teach you all you need to know to start using them safely and with confidence.
The topics and examples are no-nonsense, and get to the point without rambling or repetition. Cox-Buday respects the reader's intelligence, and is able to provide concise explanation and examples that are still accessible and not obscure. She does teach a specific design pattern that is repeated in every example until it becomes rote for the reader, but this is important as if you can and do follow this pattern, you will avoid pretty much all of the pitfalls of concurrent programming in Go. All of the pain points that everyone is always complaining about just "go away." Granted, you will not always be able to use these patterns, but they are generic enough to fit most usecases and almost all entry-level situations.
This book took me from Go virgin to having a working parallel microservice API in a week. That includes the time debugging. Though this book didn't discuss debugging multi-threaded programs, which would have been a good addition (but that's also not something you can just "splash" into a quick chapter), it turns out following the patterns put forth by Cox-Buday makes a fairly debuggable program (and I think Golang itself lends itself to programs easier to debug in a multi-threaded context, mostly by simplifying the multi-threaded programming model into a fairly clean abstraction).
If you're developing any sort of multi-threaded or network application, and Golang is even an option, it's worth doing a Go crash course and picking up this book. As someone who has done multi-threaded dev work in C and python, it absolutely would have saved me time to learn a new language and read this book.
And if you use Go, and you find channels or goroutines elusive, frustrating, buggy, or intimidating (in fact, if you still have negative things to say about them at all), I'd recommend picking up this book and seeing how you feel afterward.
November 15, 2021
Most of the time I have enjoyed reading the book where in some parts I definitely loved it while on some others I did not like it at all.
Starting with good stuff, I think that the book gives you a fantastic introduction to concurrency in Go. I really loved how the book explains from the high level how the Goroutines works, how the scheduling algorithm acts and how does it fit in the big picture.
On the other side of the coin, I felt like the author spent lots of time trying to make a point to explain a pattern making so the overall reading experience slow. Honestly, I was expecting more WHYs than HOWs, and unfortunately, after the first chapters where the author managed to get my attention it all went down due to the lack of whys more or less in the middle of the book.
I would recommend the book "Concurrency in Go" to anyone interested in learning how Go does it different from other technologies, why Go did not reinvent the wheel with those concepts and some strategies on how to use patterns. I would not recommend it though if you are looking for something advanced to understand the internals of the language.
Starting with good stuff, I think that the book gives you a fantastic introduction to concurrency in Go. I really loved how the book explains from the high level how the Goroutines works, how the scheduling algorithm acts and how does it fit in the big picture.
On the other side of the coin, I felt like the author spent lots of time trying to make a point to explain a pattern making so the overall reading experience slow. Honestly, I was expecting more WHYs than HOWs, and unfortunately, after the first chapters where the author managed to get my attention it all went down due to the lack of whys more or less in the middle of the book.
I would recommend the book "Concurrency in Go" to anyone interested in learning how Go does it different from other technologies, why Go did not reinvent the wheel with those concepts and some strategies on how to use patterns. I would not recommend it though if you are looking for something advanced to understand the internals of the language.
January 1, 2024
Even though this book is thin — it is a precious one! Probably the most significant concentration of bookmarks per book I’ve recently had. It’s great for those coming from other languages and picking up Go. Especially if you enjoyed the likes of Java Concurrency in Practice (2006) and Camel in Action (2010). Every chapter starts with seemingly correct code with some unobvious problems, followed by multiple iterations of potential solutions and their drawbacks, diving deep into explanations. I especially enjoyed the chapters on error propagation, heartbeats, and other common patterns. However, one sad thing is that it still uses somewhat outdated “done channels� instead of now widespread contexts. Just look at how exciting code examples are. And that rodent on the book cover is simply cute.
December 25, 2023
A good book that covers concurency patterns in go as well as some common patterns that could be applied outside of go, so I'd recommend this one if you're interested in either go or concurency. I did find the examples a little hard to understand especially near the end, but that is to be expected, it's a complicated topic. The writing is clear and non-obtusive. Personally I get more from the "let's build a toy x" than "here are a bunch of micro showcases for these concepts" but I understand that that is difficult if you want to be able to cover all of the things in this book. I'll be keeping it as a reference for when I want to dive into more go myself.
February 24, 2022
Go has powerful features as it could spawn the new lightweight thread very easily and channels to communicate between its goroutines. These great features turn out to bring side-effects if engineers are lacked in knowledge of the principle behind Go programming but also how to handle concurrency in general.
This book is aimed at the audience who are lacking both that knowledge, but I even recommend this to the person who has enough experience since you can see various cases might you can encounter in production.
This book is aimed at the audience who are lacking both that knowledge, but I even recommend this to the person who has enough experience since you can see various cases might you can encounter in production.
September 3, 2024
A good book on concurrency in general. It provides numerous examples in Chapters 4 and 5 on using idiomatic go primitives(select, channels, and goroutines) to achieve common yet challenging tasks. The code examples are given in complete form, even for minor changes, making it easy to follow at the cost of duplication. Overall, I appreciate how the book faithfully adheres to Go’s emphasis on explicitness by packing everything in ~210 pages.
July 23, 2020
Concurrency is what Go excels at and it’s Go’s biggest selling point. This book introduces all Go’s concurrency primitives as well as some useful concurrency patterns. It also explains briefly about the scheduling algorithm of Go’s runtime in the last chapter.
It’s a must-read if you are heading towards more advanced Go development.
It’s a must-read if you are heading towards more advanced Go development.
July 1, 2021
This book is a great introduction to Concurrency. The author explains the main blocks provided by the language to work with currency and how to use them in a real application. In case you are curious, there is also a chapter about the Go Runtime that explains what Go does under the hood to optimize a program and what tools you can use to profile your application running in production.
November 30, 2021
This book does cover the basic knowledge on concurrency in Go, very well explained in logic parts, but a bit disappointed in Chapter 5 (Concurrency at Scale) where the given examples were just too simple! I was expecting more realistic and practical examples that can be applied in different programs. But I did enjoy reading other chapters, learned a lot from the author!
September 9, 2024
I accidentally read this. It's just an entry-level book on concurrency for those unfortunate enough to have to use Go. The examples felt weird and disjointed; I doubt I would've understood much without some prior knowledge of what's going on. It includes odd sections on Go runtime behavior and queueing theory (?), just felt out of place.
July 1, 2020
A very nice book to understand concurrency topic and how it's implemented in Go. Book provides different algorithms using concurrency and channels. At the end briefly but well explained about goroutines in Go runtime.
November 1, 2017
It start very well, in the end, It seems that I miss the point the author is trying to explain.
December 28, 2017
Written with great clarity, every concept is well explained and the code is simple. Amazing writing, highly recommend!
November 11, 2018
Not as exhaustive as I’d like it to be. Good light introductory read.
August 16, 2020
Very well written. Concise and practical
December 12, 2021
Good choice of coverage, but at times indirect and verbose in its treatment
March 25, 2022
This books deals with and explains the concurrency concept with Golang well, however it will help only if you have a bit of primer on the language before putting your mind onto this.
March 27, 2022
Super dense with information, and a really good reference book. Recommend a hard copy though, the digital was hard to refer back quickly to other pages.
July 23, 2022
Really liked chapter 5.
November 10, 2023
Incredible book! So clearly written and full of great examples. Concurrency in Go explained at its best
November 30, 2023
amazing book to read about concurrency in go. it includes a lot of design pattern examples.
Displaying 1 - 30 of 36 reviews
Can't find what you're looking for?
Get help and learn more about the design.