Go Concurrency Patterns Cheat Sheet

Covers goroutines, channels, select statements, sync primitives, and common concurrency patterns like worker pools and fan-in/fan-out in Go.

2 PagesIntermediateMar 30, 2026

Goroutines & Channels

Starting goroutines and communicating over channels.

func main() {	ch := make(chan string)	go func() {		ch <- "hello from goroutine"	}()	msg := <-ch	fmt.Println(msg)	// Buffered channel	buf := make(chan int, 3)	buf <- 1	buf <- 2	close(buf)	for v := range buf {		fmt.Println(v) // ranges until channel is closed	}}

Select Statement

Waiting on multiple channel operations at once.

select {case msg1 := <-ch1:	fmt.Println("received", msg1)case msg2 := <-ch2:	fmt.Println("received", msg2)case <-time.After(1 * time.Second):	fmt.Println("timeout")default:	fmt.Println("no message ready") // non-blocking select}

sync Package

Core synchronization primitives from the standard library.

sync.Mutex- Locks a critical section; call Lock() and Unlock() (typically via defer)
sync.RWMutex- Allows multiple concurrent readers or one writer; RLock()/RUnlock() for reads
sync.WaitGroup- Waits for a collection of goroutines to finish via Add/Done/Wait
sync.Once- Ensures a function runs exactly once, e.g. for lazy initialization
sync.Map- Concurrency-safe map optimized for specific high-contention access patterns
atomic package- Lock-free atomic operations (AddInt64, LoadInt32, etc.) from sync/atomic
context.Context- Carries cancellation signals and deadlines across API boundaries and goroutines

Worker Pool Pattern

Fixed pool of goroutines processing jobs from a shared channel.

func main() {	jobs := make(chan int, 100)	results := make(chan int, 100)	var wg sync.WaitGroup	for w := 1; w <= 3; w++ {		wg.Add(1)		go func(id int) {			defer wg.Done()			for j := range jobs {				results <- j * j			}		}(w)	}	for j := 1; j <= 9; j++ {		jobs <- j	}	close(jobs)	wg.Wait()	close(results)	for r := range results {		fmt.Println(r)	}}

Common Patterns

Named concurrency patterns you'll see across Go codebases.

Fan-out- Multiple goroutines read from the same channel to parallelize work
Fan-in- Merge multiple channels into one using a dedicated merge goroutine
Pipeline- Chain stages so each stage's output channel feeds the next stage's input
Done channel- A closed channel broadcasts cancellation to every listening goroutine
context.WithCancel- Standard way to propagate cancellation through a call graph
context.WithTimeout- Cancels automatically after a duration; use with select on ctx.Done()

Pro Tip

Always know who closes a channel and only close it from the sender side — closing a channel you're only receiving from, or closing it twice, causes a panic.

Was this cheat sheet helpful?

Go Structs & Methods Cheat Sheet

Go Generics Cheat Sheet

Explore Topics

#GoConcurrencyPatterns#GoConcurrencyPatternsCheatSheet#Programming#Intermediate#GoroutinesChannels#SelectStatement#SyncPackage#WorkerPoolPattern#Concurrency#CheatSheet#SkillVeris

Sri Hayavadhana Info-Tech

Professional Web Designing Services