Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

golang-concurrency

Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes.

yzfly · AI review on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add yzfly/skills --skill golang-concurrency

About this skill


name: golang-concurrency description: "Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes." user-invocable: true license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber version: "1.1.3" openclaw: emoji: "⚡" homepage: https://github.com/samber/cc-skills-golang requires: bins: - go install: [] allowed-tools: Read Edit Write Glob Grep Bash(go:) Bash(golangci-lint:) Bash(git:*) Agent AskUserQuestion

Persona: You are a Go concurrency engineer. You assume every goroutine is a liability until proven necessary — correctness and leak-freedom come before performance.

Modes:

  • Write mode — implement concurrent code (goroutines, channels, sync primitives, worker pools, pipelines). Follow the sequential instructions below.
  • Review mode — reviewing a PR's concurrent code changes. Focus on the diff: check for goroutine leaks, missing context propagation, ownership violations, and unprotected shared state. Sequential.
  • Audit mode — auditing existing concurrent code across a codebase. Use up to 5 parallel sub-agents as described in the "Parallelizing Concurrency Audits" section.

Community default. A company skill that explicitly supersedes samber/cc-skills-golang@golang-concurrency skill takes precedence.

Go Concurrency Best Practices

Go's concurrency model is built on goroutines and channels. Goroutines are cheap but not free — every goroutine you spawn is a resource you must manage. The goal is structured concurrency: every goroutine has a clear owner, a predictable exit, and proper error propagation.

Core Principles

  1. Every goroutine must have a clear exit — without a shutdown mechanism (context, done channel, WaitGroup), they leak and accumulate until the process crashes
  2. Share memory by communicating — channels transfer ownership explicitly; mutexes protect shared state but make ownership implicit
  3. Send copies, not pointers on channels — sending pointers creates invisible shared memory, defeating the purpose of channels
  4. Only the sender closes a channel — closing from the receiver side panics if the sender writes after close
  5. Specify channel direction (chan<-, <-chan) — the compiler prevents misuse at build time
  6. Default to unbuffered channels — larger buffers mask backpressure; use them only with measured justification
  7. Always include ctx.Done() in select — without it, goroutines leak after caller cancellation
  8. Never use time.After in loops — each call creates a timer that lives until it fires, accumulating memory. Use time.NewTimer + Reset
  9. Track goroutine leaks in tests with go.uber.org/goleak

For detailed channel/select code examples, see Channels and Select Patterns.

Channel vs Mutex vs Atomic

ScenarioUseWhy
Passing data between goroutinesChannelCommunicates ownership transfer
Coordinating goroutine lifecycleChannel + contextClean shutdown with select
Protecting shared struct fieldssync.Mutex / sync.RWMutexSimple critical sections
Simple counters, flagssync/atomicLock-free, lower overhead
Many readers, few writers on a mapsync.MapOptimized for read-heavy workloads. Concurrent map read/write causes a hard crash
Caching expensive computationssync.Once / singleflightExecute once or deduplicate

WaitGroup vs errgroup

NeedUseWhy
Wait for goroutines, errors not neededsync.WaitGroupFire-and-forget
Wait + collect first errorerrgroup.GroupError propagation
Wait + cancel siblings on first errorerrgroup.WithContextContext cancellation on error
Wait + limit concurrencyerrgroup.SetLimit(n)Built-in worker pool

Sync Primitives Quick Reference

PrimitiveUse caseKey notes
sync.MutexProtect shared stateKeep critical sections short; never hold across I/O
sync.RWMutexMany readers, few writersNever upgrade RLock to Lock (deadlock)
sync/atomicSimple counters, flagsPrefer typed atomics (Go 1.19+): atomic.Int64, atomic.Bool
sync.MapConcurrent map, read-heavyNo explicit locking; use RWMutex+map when writes dominate
sync.PoolReuse temporary objectsAlways Reset() before Put(); reduces GC pressure
sync.OnceOne-time initializationGo 1.21+: OnceFunc, OnceValue, OnceValues
sync.WaitGroupWait for goroutine completionAdd before go; Go 1.24+: wg.Go() simplifies usage
x/sync/singleflightDeduplicate concurrent callsCache stampede prevention
x/sync/errgroupGoroutine group + errorsSetLimit(n) replaces hand-rolled worker pools

For detailed examples and anti-patterns, see Sync Primitives Deep Dive.

Concurrency Checklist

Before spawning a goroutine, answer:

  • How will it exit? — context cancellation, channel close, or explicit signal
  • Can I signal it to stop? — pass context.Context or done channel
  • Can I wait for it? — sync.WaitGroup or errgroup
  • Who owns the channels? — creator/sender owns and closes
  • Should this be synchronous instead? — don't add concurrency without measured need

Pipelines and Worker Pools

For pipeline patterns (fan-out/fan-in, bounded workers, generator chains, Go 1.23+ iterators, samber/ro), see Pipelines and Worker Pools.

Parallelizing Concurrency Audits

When auditing concu

Read the complete source ↗