Concurrency in Go

Table of contents

1. Preface
   1. Who Should Read This Book
   2. Navigating This Book
   3. Online Resources
   4. Conventions Used in This Book
   5. Using Code Examples
   6. O’Reilly Safari
   7. How to Contact Us
   8. Acknowledgments
2. 1. An Introduction to Concurrency
   1. Moore’s Law, Web Scale, and the Mess We’re In
   2. Why Is Concurrency Hard?
      1. Race Conditions
      2. Atomicity
      3. Memory Access Synchronization
      4. Deadlocks, Livelocks, and Starvation
      5. Determining Concurrency Safety
   3. Simplicity in the Face of Complexity
3. 2. Modeling Your Code: Communicating Sequential Processes
   1. The Difference Between Concurrency and Parallelism
   2. What Is CSP?
   3. How This Helps You
   4. Go’s Philosophy on Concurrency
4. 3. Go’s Concurrency Building Blocks
   1. Goroutines
   2. The sync Package
      1. WaitGroup
      2. Mutex and RWMutex
      3. Cond
      4. Once
      5. Pool
   3. Channels
   4. The select Statement
   5. The GOMAXPROCS Lever
   6. Conclusion
5. 4. Concurrency Patterns in Go
   1. Confinement
   2. The for-select Loop
   3. Preventing Goroutine Leaks
   4. The or-channel
   5. Error Handling
   6. Pipelines
      1. Best Practices for Constructing Pipelines
      2. Some Handy Generators
   7. Fan-Out, Fan-In
   8. The or-done-channel
   9. The tee-channel
   10. The bridge-channel
   11. Queuing
   12. The context Package
   13. Summary
6. 5. Concurrency at Scale
   1. Error Propagation
   2. Timeouts and Cancellation
   3. Heartbeats
   4. Replicated Requests
   5. Rate Limiting
   6. Healing Unhealthy Goroutines
   7. Summary
7. 6. Goroutines and the Go Runtime
   1. Work Stealing
      1. Stealing Tasks or Continuations?
   2. Presenting All of This to the Developer
   3. Conclusion
8. A. Appendix
   1. Anatomy of a Goroutine Error
   2. Race Detection
   3. pprof
9. Index