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.

samber · AI review on file

Installation

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

npx skills add samber/cc-skills-golang --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, Codex or similar harness, and for projects using Golang. metadata: author: samber version: "1.2.0" 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 paths:

  • "**/*.go"

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

Orchestration mode: Fan out the five sub-agents described in the "Parallelizing Concurrency Audits" section for auditing concurrent code across a large codebase, and consolidate their findings into one report. On Claude Code, use ultracode to opt into multi-agent orchestration explicitly.

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. Avoid repeated time.After in hot loops — each call allocates a timer and creates unnecessary churn; use time.NewTimer + Reset for long-running loops
  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.WaitGroupWaiting for simple goroutinesGo 1.25+: prefer wg.Go(func(){ ... }) for fire-and-wait tasks that do not panic and do not need error propagation. For Go <1.25 use Add/Done. For errors/cancellation/limits, use errgroup with context.
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 don
Read the complete source ↗