Write concurrent Go like a professional: goroutines, channels, context, tests, benchmarks and clean design.
- 28 lessons
- 7 units
- 5 h 39 m in all
- £0, for good
what’s inside.
For people who build things on their own and want code that others trust and can change.
Twenty-eight lessons take you from your first goroutine to worker pools, pipelines, cancellation and code that never races or leaks. You learn to test with tables, measure with benchmarks and shape your types with embedding and functional options. You finish by shipping a concurrent job runner that handles bad input and always prints the same sorted report.
every lesson goes the same way.
- meet it
- guess first
- your turn
- fix it
- nailed it
unit 1
Many things at once
Run work side by side, then wait for every piece to finish.
- A goroutine runs alongside10 minStart work that runs at the same time as
main, then wait for it to finish. - Many goroutines, one wait12 minStart a goroutine for every item and collect the answers in a fixed order.
- The loop variable trap12 minSpot the Go 1.16 bug where every goroutine sees the same loop value.
- When one goroutine panics13 minStop one bad job from crashing every other job in the program.
unit 2
Channels
Pass values safely between goroutines, and know when they have all arrived.
- A channel hands values over11 minPass a value from one goroutine to another, safely and in order.
- Buffered channels11 minGive a channel room for a few values so senders do not always wait.
- Closing and ranging12 minSay when no more values are coming, and loop until they have all arrived.
- Channel directions12 minWrite function types that say who may send and who may receive.
unit 3
Waiting on many things
Listen to several channels at once, never wait too long, and stop on a signal.
- select waits on many12 minListen to several channels at once and handle whichever speaks first.
- Never wait11 minTry a send or receive, and do something else if it cannot happen now.
- Timeouts12 minGive slow work a time limit, and move on when it runs out.
- A done channel12 minTell every worker to stop at once with a single
close.
unit 4
Sharing safely
Keep shared data correct when many goroutines touch it at once.
- Data races13 minRecognise the bug that hides when two goroutines share one variable.
- Mutex12 minGuard shared data so only one goroutine at a time can change it.
- Atomic counters11 minCount safely from many goroutines without a lock.
- Share by communicating13 minGive data a single owner goroutine and talk to it over channels.
unit 5
Concurrency patterns
Use the proven shapes: worker pools, pipelines, fan-out and fan-in.
- Worker pools12 minShare a long queue of jobs between a fixed number of goroutines.
- Pipelines12 minChain small stages together with channels, like a factory line.
- Fan out, fan in13 minSpread work across many goroutines, then gather every result into one channel.
- Errors from workers12 minBring every error home from your goroutines and report it in a fixed order.
unit 6
Stopping on time
Cancel work, set deadlines and make sure every goroutine finishes.
- Context and cancelling12 minHand a stop signal to your goroutines and use it to end their work.
- Deadlines and timeouts12 minGive a whole job a time limit that every part of it can see.
- Stop without leaking13 minMake sure every goroutine you start has a way to finish.
- Context in a web handler13 minStop slow work when the visitor has already gone.
unit 7
Code like a professional
Test, measure and shape your code the way experienced Go developers do.
- Table-driven tests12 minTest many cases with one loop and clear failure messages.
- Benchmarks and profiling14 minMeasure how fast your code is and how much memory it asks for.
- Embedding12 minBuild a type out of smaller types and reuse their methods.
- Functional options13 minBuild things with sensible defaults and settings that read like English.