Habilidades go-concurrency-patterns
📦

go-concurrency-patterns

Seguro

Domine os Padrões de Concorrência em Go

Também disponível em: wshobson

Construa aplicações concorrentes em Go com confiança. Aprenda padrões prontos para produção para goroutines, channels, worker pools e encerramento gracioso para evitar condições de corrida e vazamentos de recursos.

Suporta: Claude Codex Code(CC)
🥉 75 Bronze
1

Baixar o ZIP da skill

2

Upload no Claude

Vá em Configurações → Capacidades → Skills → Upload skill

3

Ative e comece a usar

Testar

A utilizar "go-concurrency-patterns". Crie um worker pool com 3 workers que processa jobs de um channel

Resultado esperado:

Aqui está uma implementação de worker pool com 3 workers que processa jobs concorrentemente e coleta resultados através de um channel de resultados com sincronização adequada usando sync.WaitGroup.

A utilizar "go-concurrency-patterns". Mostre-me como usar errgroup para requisições HTTP concorrentes

Resultado esperado:

Este exemplo demonstra golang.org/x/sync/errgroup para buscar múltiplas URLs concorrentemente onde o primeiro erro cancela todas as requisições pendentes através de propagação de contexto.

A utilizar "go-concurrency-patterns". Implemente um semáforo para limitar operações concorrentes

Resultado esperado:

Forneço duas abordagens de semáforo: usando golang.org/x/sync/semaphore.Weighted para semáforos ponderados e um semáforo baseado em channel struct{} para rate limiting simples.

Auditoria de Segurança

Seguro
v1 • 2/25/2026

All 44 static analysis findings are false positives from markdown-enclosed Go code examples. The skill contains legitimate educational content about Go concurrency patterns with no executable code or security risks.

2
Arquivos analisados
691
Linhas analisadas
0
achados
1
Total de auditorias
Nenhum problema de segurança encontrado
Auditado por: claude

Pontuação de qualidade

38
Arquitetura
100
Manutenibilidade
87
Conteúdo
50
Comunidade
100
Segurança
100
Conformidade com especificações

O Que Você Pode Construir

Construir microsserviços concorrentes

Crie serviços Go escaláveis com worker pools que lidam com múltiplas requisições concorrentemente enquanto gerenciam recursos de forma eficiente

Implementar pipelines de processamento de dados

Projete pipelines fan-out/fan-in para processar grandes conjuntos de dados em paralelo com tratamento de erros e cancelamento adequados

Depurar condições de corrida

Identifique e corrija bugs de concorrência em código Go existente usando padrões de sincronização adequados e ferramentas de detecção de race conditions

Tente Estes Prompts

Criar um worker pool básico 
Mostre-me como criar um worker pool em Go que processa 100 jobs com 5 workers concorrentes
Implementar encerramento gracioso 
Escreva um servidor Go com encerramento gracioso que lida com sinais SIGTERM e aguarda as requisições em andamento serem concluídas
Construir um pipeline fan-out 
Crie um pipeline fan-out/fan-in em Go que processa itens através de 3 estágios com 5 workers por estágio
Corrigir vazamentos de goroutine 
Revise este código Go e identifique potenciais vazamentos de goroutine, depois mostre-me como corrigi-los usando cancelamento de contexto

Melhores Práticas

  • Sempre use context.Context para cancelamento e deadlines em operações concorrentes
  • Feche channels apenas do lado do remetente para evitar panics
  • Prefira channels sobre mutexes para comunicação entre goroutines
  • Use sync.WaitGroup ou errgroup para aguardar a conclusão de goroutines

Evitar

  • Usar time.Sleep para sincronização ao invés de primitivas adequadas como channels ou WaitGroup
  • Fechar channels do lado do receptor, o que causa panic
  • Esquecer de verificar ctx.Done() o que leva a vazamentos de goroutine
  • Compartilhar memória entre goroutines sem sincronização adequada

Perguntas Frequentes

Qual é a diferença entre programação concorrente e paralela em Go?
Concorrência é sobre estruturar seu programa para lidar com múltiplas tarefas simultaneamente, enquanto paralelismo é sobre executar múltiplas tarefas ao mesmo tempo em múltiplos núcleos de CPU. As goroutines do Go permitem design concorrente que o runtime do Go pode executar em paralelo.
Quando devo usar channels versus mutexes?
Use channels quando goroutines precisam se comunicar ou coordenar (compartilhando memória através de comunicação). Use mutexes quando precisar proteger estado compartilhado de acesso concorrente (compartilhando memória ao compartilhar memória). Channels são geralmente mais idiomáticos em Go.
Como prevenir vazamentos de goroutine?
Sempre forneça um caminho de saída para goroutines usando cancelamento de contexto, verificando ctx.Done() em loops, garantindo que channels sejam eventualmente fechados, e usando padrões como errgroup que automaticamente lidam com cleanup.
Qual é o propósito do sync.WaitGroup?
sync.WaitGroup permite que você aguarde um conjunto de goroutines terminar. Você adiciona ao contador com Add(), decrementa com Done() quando uma goroutine completa, e bloqueia com Wait() até o contador chegar a zero.
Como detectar race conditions no meu código Go?
Execute seus testes ou binário com o detector de race conditions habilitado usando 'go test -race ./...' ou 'go run -race main.go'. O detector de race conditions monitora acesso à memória e reporta leituras/escritas concorrentes em memória compartilhada sem sincronização.
Qual é a diferença entre channels bufferizados e não-bufferizados?
Channels não-bufferizados (make(chan T)) requerem que remetente e receptor estejam prontos simultaneamente, fornecendo sincronização. Channels bufferizados (make(chan T, n)) armazenam até n valores sem um receptor, permitindo que remetentes prossigam até o buffer ficar cheio.

Detalhes do Desenvolvedor

Autor

sickn33

Licença

MIT

Repositório

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/go-concurrency-patterns

Referência

main

Estrutura de arquivos

📁 resources/

📄 implementation-playbook.md

📄 SKILL.md