Concurrency in Go: Tools and Techniques for Developers

238 Pages·2017·4.305 MB·English

by  Katherine Cox-Buday

Concurrency
in Go
TOOLS & TECHNIQUES
FOR DEVELOPERS
Katherine Cox-Buday

Concurrency in Go
Tools and Techniques for Developers
Katherine Cox-Buday
BBeeiijjiinngg BBoossttoonn FFaarrnnhhaamm SSeebbaassttooppooll TTookkyyoo
Concurrency in Go
by Katherine Cox-Buday
Copyright © 2017 Katherine Cox-Buday. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are
also available for most titles (http://oreilly.com/safari). For more information, contact our corporate/insti‐
tutional sales department: 800-998-9938 or [email protected].
Editor: Dawn Schanafelt Indexer: Judy McConville
Production Editor: Nicholas Adams Interior Designer: David Futato
Copyeditor: Kim Cofer Cover Designer: Karen Montgomery
Proofreader: Sonia Saruba Illustrator: Rebecca Demarest
August 2017: First Edition
Revision History for the First Edition
2017-07-18: First Release
See http://oreilly.com/catalog/errata.csp?isbn=9781491941195 for release details.
The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. Concurrency in Go, the cover image,
and related trade dress are trademarks of O’Reilly Media, Inc.
While the publisher and the author have used good faith efforts to ensure that the information and
instructions contained in this work are accurate, the publisher and the author disclaim all responsibility
for errors or omissions, including without limitation responsibility for damages resulting from the use of
or reliance on this work. Use of the information and instructions contained in this work is at your own
risk. If any code samples or other technology this work contains or describes is subject to open source
licenses or the intellectual property rights of others, it is your responsibility to ensure that your use
thereof complies with such licenses and/or rights.
978-1-491-94119-5
[LSI]
For L. and N. whose sacrifice made this book possible. Of everything in my life,
you are the best. I love you.

Table of Contents
Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vii
1. An Introduction to Concurrency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Moore’s Law, Web Scale, and the Mess We’re In 2
Why Is Concurrency Hard? 4
Race Conditions 4
Atomicity 6
Memory Access Synchronization 8
Deadlocks, Livelocks, and Starvation 10
Determining Concurrency Safety 18
Simplicity in the Face of Complexity 20
2. Modeling Your Code: Communicating Sequential Processes. . . . . . . . . . . . . . . . . . . . . . . 23
The Difference Between Concurrency and Parallelism 23
What Is CSP? 26
How This Helps You 29
Go’s Philosophy on Concurrency 31
3. Go’s Concurrency Building Blocks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Goroutines 37
The sync Package 47
WaitGroup 47
Mutex and RWMutex 49
Cond 52
Once 57
Pool 59
Channels 64
The select Statement 78
v
The GOMAXPROCS Lever 83
Conclusion 83
4. Concurrency Patterns in Go. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Confinement 85
The for-select Loop 89
Preventing Goroutine Leaks 90
The or-channel 94
Error Handling 97
Pipelines 100
Best Practices for Constructing Pipelines 104
Some Handy Generators 109
Fan-Out, Fan-In 114
The or-done-channel 119
The tee-channel 120
The bridge-channel 122
Queuing 124
The context Package 131
Summary 145
5. Concurrency at Scale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Error Propagation 147
Timeouts and Cancellation 155
Heartbeats 161
Replicated Requests 172
Rate Limiting 174
Healing Unhealthy Goroutines 188
Summary 194
6. Goroutines and the Go Runtime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Work Stealing 197
Stealing Tasks or Continuations? 204
Presenting All of This to the Developer 212
Conclusion 212
A. Appendix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
vi | Table of Contents
Preface
Hey, welcome to Concurrency in Go! I’m delighted that you’ve picked up this book
and excited to join you in exploring the topic of concurrency in Go over the next six
chapters!
Go is a wonderful language. When it was first announced and birthed into the world,
I remember exploring it with great interest: it was terse, compiled incredibly fast, per‐
formed well, supported duck typing, and—to my delight—I found working with its
concurrency primitives to be intuitive. The first time I used the go keyword to create
a goroutine (something we’ll cover, I promise!) I got this silly grin on my face. I had
worked with concurrency in several languages, but I had never worked in a language
that made concurrency so easy (which is not to say they don’t exist; I just hadn’t used
any). I had found my way to Go.
Over the years I moved from writing personal scripts in Go, to personal projects,
until I found myself working on a many-hundreds-of-thousands-of-lines project pro‐
fessionally. Along the way the community was growing with the language, and we
were collectively discovering best practices for working with concurrency in Go. A
few people gave talks on patterns they had discovered. But there still weren’t many
comprehensive guides on how to wield concurrency in Go in the community.
It was with this in mind that I set out to write this book. I wanted the community to
have access to high-quality and comprehensive information about concurrency in
Go: how to use it, best practices and patterns for incorporating it into your systems,
and how it all works under the covers. I have done my best to strike a balance
between these concerns.
I hope this book proves useful!
vii
Who Should Read This Book
This book is meant for developers who have some experience with Go; I make no
attempt to explain the basic syntax of the language. Knowledge of how concurrency is
presented in other languages is useful, but not necessary.
By the end of this book we will have discussed the entire stack of Go concurrency
concerns: common concurrency pitfalls, motivation behind the design of Go’s con‐
currency, the basic syntax of Go’s concurrency primitives, common concurrency pat‐
terns, patterns of patterns, and various tooling that will help you along the way.
Because of the breadth of topics we’ll cover, this book will be useful to various cross-
sections of people. The next section will help you navigate this book depending on
what needs you have.
Navigating This Book
When I read technical books, I usually hop around to the areas that pique my inter‐
est. Or, if I’m trying to ramp up on a new technology for work, I frantically skim for
the bits that are immediately relevant to my work. Whatever your use case is, here’s a
roadmap for the book with the hopes that it help guide you to where you need to be!
Chapter 1, An Introduction to Concurrency
This chapter will give you a broad historical perspective on why concurrency is
an important concept, and also discuss some of the fundamental problems that
make concurrency difficult to get correct. It also briefly touches on how Go helps
ease some of this burden.
If you have a working knowledge of concurrency or just want to get to the tech‐
nical aspects of how to use Go’s concurrency primitives, it’s safe to skip this
chapter.
Chapter 2, Modeling Your Code: Communicating Sequential Processes
This chapter deals with some of the motivational factors that contributed to Go’s
design. This will help give you some context for conversations with others in the
Go community and help to frame your understanding of why things work the
way they do in the language.
Chapter 3, Go’s Concurrency Building Blocks
Here we’ll start to dig into the syntax of Go’s concurrency primitives. We’ll also
cover the sync package, which is responsible for handling Go’s memory access
synchronization. If you haven’t used concurrency within Go before and are look‐
ing to hop right in, this is the place to start.
viii | Preface