跳到主内容
智客 ZICQ

技能库 智客分类:设计创意 golang-concurrency

Golang Concurrency

Golang货币设计——循规蹈矩的生命周期和漏泄预防、渠道和 " 选择 " 、渠道所有权和方向,`协同 ' 。 Mutex " / " RWMutex " / " sync.Map " / " sync.Once " /原子、 " errgroup " 、 " single Flight " 、工人池和风扇出/风扇入管道。 在同时写作或审查时使用 去代码,当选择频道和变种, 当保护共享地图或计数器, 或者当一个goroutine 没有明确的退出。 不用于与 " 无 " 恐慌、切片别名或数字溢出等货币无关的防御编码(-见`Samber/cc-skill-golang@golang-safety'技能),也不用于调试具体吊死、坠毁或事后赛跑程序(-) 见`Samber/cc-skilling-golang@golang-troubleshooting'技能'.

44568 安装量

官方网址:作者主页

技能介绍

先看中文介绍;官方 description 原文单独保留,不改写 SKILL.md。

做什么

Golang货币设计——循规蹈矩的生命周期和漏泄预防、渠道和 " 选择 " 、渠道所有权和方向,`协同 ' 。 Mutex`/`RWMutex'/`Sync.Map'/`Sync.Once'/原子、`errgroup'、`Single Flight'、工人池和风扇出/风扇入管道

何时用

编写或同时审查 去代码,当选择频道和变种,当保护共享地图或计数器,或者当一个goroutine没有明确的退出时. 不属于与 " 无 " 恐慌、切片别名或数字外溢等货币无关的防御编码(-见`s

代理如何加载

按 Agent Skills 渐进披露:启动时只加载 name 与 description(约 100 token);任务匹配后才读入整份 SKILL.md 正文;scripts/、references/、assets/ 仅在需要时再读。 本文件正文结构:Go Concurrency Best Practices、Core Principles、Channel vs Mutex vs Atomic、WaitGroup vs errgroup、Sync Primitives Quick Reference、Concurrency Checklist。

文件分析

文件分析:除 SKILL.md 外,正文引用了 references/channels-and-select.md、references/sync-primitives.md、references/pipelines.md,属于带资源的技能包,这些文件按需再读。

官方 description(原文)

Golang concurrency design — goroutine lifecycle and leak prevention, channels and `select`, channel ownership and direction, `sync.Mutex`/`RWMutex`/`sync.Map`/`sync.Once`/atomics, `errgroup`, `singleflight`, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow (→ See `samber/cc-skills-golang@golang-safety` skill), and not for debugging a specific hung, crashing, or racing program after the fact (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).

Go Concurrency Best PracticesCore PrinciplesChannel vs Mutex vs AtomicWaitGroup vs errgroupSync Primitives Quick ReferenceConcurrency ChecklistPipelines and Worker PoolsParallelizing Concurrency AuditsCommon MistakesCross-ReferencesGoroutine leak profileReferences

兼容:Designed for Claude Code, Codex or similar harness, and for projects using Golang. · 许可:MIT · allowed-tools:Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(git:*) Agent AskUserQuestion

来源分类:skills.sh agent-skill

SKILL.md 与 Agent 调用

官方规范 ↗
name
golang-concurrency
description
Golang concurrency design — goroutine lifecycle and leak prevention, channels and `select`, channel ownership and direction, `sync.Mutex`/`RWMutex`/`sync.Map`/`sync.Once`/atomics, `errgroup`, `singleflight`, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow (→ See `samber/cc-skills-golang@golang-safety` skill), and not for debugging a specific hung, crashing, or racing program after the fact (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).
compatibility
Designed for Claude Code, Codex or similar harness, and for projects using Golang.
allowed-tools
Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(git:*) Agent AskUserQuestion实验字段,支持情况取决于客户端;字段声明本身不会授予工具权限。
许可
MIT
  1. 发现技能客户端向 Agent 提供名称与描述目录。
  2. 匹配与调用用户指定或任务匹配后,载入 SKILL.md 指令。
  3. 按需加载按步骤读取参考文档、使用脚本与素材。
指令中引用的文件 · 3
  • references/channels-and-select.md
  • references/sync-primitives.md
  • references/pipelines.md

以下路径提取自原文;文件是否齐全请以来源仓库中的完整目录为准。

具体调用语法与可用工具以目标 Agent 客户端为准。 查看调用机制说明 ↗

安装这个技能

Skills CLI ↗

先选择目标 Agent 和安装范围,保留技能包的附属文件,安装后检查客户端能否发现该技能。

该技能引用了附属文件,请从来源获取完整目录;仅复制 SKILL.md 可能缺少依赖。

交给 Agent 安装

复制安装指令给支持 Agent Skills 的代理,确认其中的目标目录与客户端匹配。

把 Agent Skill「golang-concurrency」安装到我的项目:SKILL.md 原文与官方 description 见 https://zicq.com/zh/skills/skl-4cb830587066411a-%E6%88%88%E5%85%B0%E5%85%8B.html
请存为 .cursor/skills/golang-concurrency/SKILL.md 或 .claude/skills/golang-concurrency/SKILL.md,frontmatter 的 name 与 description 保持原样,不要改写。
该技能还带 scripts/、references/、assets/ 等文件,请从 https://github.com/samber/cc-skills-golang 取完整目录,不要只建一个 SKILL.md。

GitHub 完整包 ↗

终端安装 · Skills CLI

需要 Node.js 与 npx。先查看仓库技能列表,确认实际名称。

npx skills add 'https://github.com/samber/cc-skills-golang' --list

npx skills add 'https://github.com/samber/cc-skills-golang' --skill 'golang-concurrency'

CLI 会交互选择目标 Agent,默认安装到项目;用户级安装使用 -g。先通过查看命令核对仓库内容,再用 npx skills list 检查已安装技能。

阅读排版

name: golang-concurrency description: "Golang concurrency design — goroutine lifecycle and leak prevention, channels and select, channel ownership and direction, sync.Mutex/RWMutex/sync.Map/sync.Once/atomics, errgroup, singleflight, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow (→ See samber/cc-skills-golang@golang-safety skill), and not for debugging a specific hung, crashing, or racing program after the fact (→ See samber/cc-skills-golang@golang-troubleshooting skill)." 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.1" 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

| Scenario | Use | Why | | --- | --- | --- | | Passing data between goroutines | Channel | Communicates ownership transfer | | Coordinating goroutine lifecycle | Channel + context | Clean shutdown with select | | Protecting shared struct fields | sync.Mutex / sync.RWMutex | Simple critical sections | | Simple counters, flags | sync/atomic | Lock-free, lower overhead | | Many readers, few writers on a map | sync.Map | Optimized for read-heavy workloads. Concurrent map read/write causes a hard crash | | Caching expensive computations | sync.Once / singleflight | Execute once or deduplicate |

WaitGroup vs errgroup

| Need | Use | Why | | --- | --- | --- | | Wait for goroutines, errors not needed | sync.WaitGroup | Fire-and-forget | | Wait + collect first error | errgroup.Group | Error propagation | | Wait + cancel siblings on first error | errgroup.WithContext | Context cancellation on error | | Wait + limit concurrency | errgroup.SetLimit(n) | Built-in worker pool |

Sync Primitives Quick Reference

| Primitive | Use case | Key notes | | --- | --- | --- | | sync.Mutex | Protect shared state | Keep critical sections short; never hold across I/O | | sync.RWMutex | Many readers, few writers | Never upgrade RLock to Lock (deadlock) | | sync/atomic | Simple counters, flags | Prefer typed atomics (Go 1.19+): atomic.Int64, atomic.Bool | | sync.Map | Concurrent map, read-heavy | No explicit locking; use RWMutex+map when writes dominate | | sync.Pool | Reuse temporary objects | Always Reset() before Put(); reduces GC pressure | | sync.Once | One-time initialization | Go 1.21+: OnceFunc, OnceValue, OnceValues | | sync.WaitGroup | Waiting for simple goroutines | Go 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/singleflight | Deduplicate concurrent calls | Cache stampede prevention | | x/sync/errgroup | Goroutine group + errors | SetLimit(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 concurrency across a large codebase, use up to 5 parallel sub-agents:

  1. Find all goroutine spawns (go func, go method) and verify shutdown mechanisms
  2. Search for mutable globals and shared state without synchronization
  3. Audit channel usage — ownership, direction, closure, buffer sizes
  4. Find time.After in loops, missing ctx.Done() in select, unbounded spawning
  5. Check mutex usage, sync.Map, atomics, and thread-safety documentation

Common Mistakes

| Mistake | Fix | | --- | --- | | Fire-and-forget goroutine | Provide stop mechanism (context, done channel) | | Closing channel from receiver | Only the sender closes | | time.After in hot loop | Reuse time.NewTimer + Reset | | Missing ctx.Done() in select | Always select on context to allow cancellation | | Unbounded goroutine spawning | Use errgroup.SetLimit(n) or semaphore | | Sharing pointer via channel | Send copies or immutable values | | wg.Add inside goroutine | Call Add before go — Wait may return early otherwise | | Forgetting -race in CI | Always run go test -race ./... | | Mutex held across I/O | Keep critical sections short |

Cross-References

  • → See samber/cc-skills-golang@golang-performance skill for false sharing, cache-line padding, sync.Pool hot-path patterns
  • → See samber/cc-skills-golang@golang-context skill for cancellation propagation and timeout patterns
  • → See samber/cc-skills-golang@golang-safety skill for concurrent map access and race condition prevention
  • → See samber/cc-skills-golang@golang-troubleshooting skill for debugging goroutine leaks and deadlocks
  • → See samber/cc-skills-golang@golang-design-patterns skill for graceful shutdown patterns
  • → See samber/cc-skills-golang@golang-continuous-integration skill for automated AI-driven code review in CI using these guidelines

Goroutine leak profile

The goroutine leak profile (experimental behind GOEXPERIMENT=goroutineleakprofile in Go 1.26) is generally available in runtime/pprof since Go 1.27 — no build flag required. It is a useful production-oriented leak signal alongside the existing tools below.

curl http://localhost:6060/debug/pprof/goroutineleak?debug=2
go tool pprof http://localhost:6060/debug/pprof/goroutineleak

Keep existing tools:

  • tests: go.uber.org/goleak
  • runtime count: runtime.NumGoroutine()
  • stack dump: /debug/pprof/goroutine?debug=2
  • race checks: go test -race ./...

References

相关技能

设计创意

Automation Workflows

设计和实施自动化工作流程,以节省时间和规模化操作作为独家. 用于识别重复任务实现自动化,构建跨工具的工作流程,设置触发器和行动,或优化现有自动化. 包括自动化机会识别,工作流程设计,工具选择(Zapier,Make,n8n),测试,和维护. 触发"自动","自动","工作流程自动…

设计创意

Ui Ux Pro Max

UI/UX设计智能及建筑抛光接口实施指导. 当用户要求UI设计,UX流量,信息架构,视觉风格方向,设计系统/托盘,组件规格,副本/显微镜,可访问性,或生成/critique/refine前端UI(HTML/CSS/JS,React,Next.js,Vue,Svelte,Tailw…

设计创意

Frontend Design

创建美丽现代UI的专家前端设计指南. 在构建起落架页面,仪表板,或任何用户界面时使用.

设计创意

N8n Workflow Automation

设计和输出 n8n 工作流程 JSON 有强力触发器, idempotency, 错误处理, 记录, 重试, 以及 人入"一站"审查队列. 当您需要可审计的自动化时使用.