Fähigkeiten go-concurrency-patterns
📦

go-concurrency-patterns

Sicher

Meistern Sie Go-Concurrency-Muster

Auch verfügbar von: wshobson

Erstellen Sie mit Zuversicht nebenläufige Go-Anwendungen. Lernen Sie produktionsreife Muster für Goroutines, Channels, Worker-Pools und graceful Shutdown, um Race Conditions und Ressourcenlecks zu vermeiden.

Unterstützt: Claude Codex Code(CC)
🥉 75 Bronze
1

Die Skill-ZIP herunterladen

2

In Claude hochladen

Gehe zu Einstellungen → Fähigkeiten → Skills → Skill hochladen

3

Einschalten und loslegen

Teste es

Verwendung von "go-concurrency-patterns". Erstelle einen Worker-Pool mit 3 Workern, der Jobs von einem Channel verarbeitet

Erwartetes Ergebnis:

Hier ist eine Worker-Pool-Implementierung mit 3 Workern, die Jobs nebenläufig verarbeitet und Ergebnisse über einen Results-Channel sammelt, mit korrekter Synchronisation mithilfe von sync.WaitGroup.

Verwendung von "go-concurrency-patterns". Zeige mir, wie man errgroup für nebenläufige HTTP-Anfragen verwendet

Erwartetes Ergebnis:

Dieses Beispiel demonstriert golang.org/x/sync/errgroup, um mehrere URLs gleichzeitig abzurufen, wobei der erste Fehler alle ausstehenden Anfragen durch Context-Propagation abbricht.

Verwendung von "go-concurrency-patterns". Implementiere einen Semaphore zur Begrenzung gleichzeitiger Operationen

Erwartetes Ergebnis:

Ich stelle zwei Semaphore-Ansätze vor: golang.org/x/sync/semaphore.Weighted für gewichtete Semaphoren und einen channel-basierten struct{}-Semaphor für einfaches Rate-Limiting.

Sicherheitsaudit

Sicher
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
Gescannte Dateien
691
Analysierte Zeilen
0
befunde
1
Gesamtzahl Audits
Keine Sicherheitsprobleme gefunden
Auditiert von: claude

Qualitätsbewertung

38
Architektur
100
Wartbarkeit
87
Inhalt
50
Community
100
Sicherheit
100
Spezifikationskonformität

Was du bauen kannst

Nebenläufige Microservices entwickeln

Erstellen Sie skalierbare Go-Dienste mit Worker-Pools, die mehrere Anfragen gleichzeitig verarbeiten und dabei Ressourcen effizient verwalten

Datenverarbeitungspipelines implementieren

Entwerfen Sie Fan-out/Fan-in-Pipelines zur parallelen Verarbeitung großer Datensätze mit ordnungsgemäßer Fehlerbehandlung und Cancellation

Race Conditions debuggen

Identifizieren und beheben Sie Concurrency-Fehler in vorhandenem Go-Code mit geeigneten Synchronisationsmustern und Race-Detection-Tools

Probiere diese Prompts

Einen einfachen Worker-Pool erstellen 
Zeige mir, wie man in Go einen Worker-Pool erstellt, der 100 Jobs mit 5 gleichzeitigen Workern verarbeitet
Graceful Shutdown implementieren 
Schreibe einen Go-Server mit Graceful Shutdown, der SIGTERM-Signale verarbeitet und darauf wartet, dass laufende Anfragen abgeschlossen werden
Eine Fan-out-Pipeline bauen 
Erstelle eine Fan-out/Fan-in-Pipeline in Go, die Elemente durch 3 Stufen mit jeweils 5 Workern pro Stufe verarbeitet
Goroutine-Leaks beheben 
Überprüfe diesen Go-Code und identifiziere potenzielle Goroutine-Leaks, zeige mir dann, wie man sie mit Context-Cancellation behebt

Bewährte Verfahren

  • Verwenden Sie immer context.Context für Cancellation und Deadlines bei nebenläufigen Operationen
  • Schließen Sie Channels nur von der Sender-Seite, um Panics zu vermeiden
  • Bevorzugen Sie Channels gegenüber Mutexes für die Kommunikation zwischen Goroutines
  • Verwenden Sie sync.WaitGroup oder errgroup, um auf den Abschluss von Goroutines zu warten

Vermeiden

  • Verwendung von time.Sleep für Synchronisation anstelle geeigneter Primitiven wie Channels oder WaitGroup
  • Schließen von Channels von der Empfänger-Seite, was zu Panics führt
  • Vergessen, ctx.Done() zu prüfen, was zu Goroutine-Leaks führt
  • Gemeinsame Nutzung von Speicher zwischen Goroutines ohne ordnungsgemäße Synchronisation

Häufig gestellte Fragen

Was ist der Unterschied zwischen nebenläufiger und paralleler Programmierung in Go?
Concurrency betrifft die Strukturierung Ihres Programms zur gleichzeitigen Bearbeitung mehrerer Aufgaben, während Parallelität die tatsächliche Ausführung mehrerer Aufgaben zur gleichen Zeit auf mehreren CPU-Kernen bezeichnet. Gos Goroutines ermöglichen nebenläufiges Design, das die Go-Runtime parallel ausführen kann.
Wann sollte ich Channels gegenüber Mutexes verwenden?
Verwenden Sie Channels, wenn Goroutines kommunizieren oder sich koordinieren müssen (Sharing Memory by Communicating). Verwenden Sie Mutexes, wenn Sie gemeinsamen Zustand vor nebenläufigem Zugriff schützen müssen (Sharing Memory by Sharing Memory). Channels sind in Go im Allgemeinen idiomatischer.
Wie verhindere ich Goroutine-Leaks?
Stellen Sie stets einen Exit-Pfad für Goroutines bereit, indem Sie Context-Cancellation verwenden, ctx.Done() in Schleifen prüfen, sicherstellen, dass Channels irgendwann geschlossen werden, und Muster wie errgroup verwenden, die Cleanup automatisch handhaben.
Welchen Zweck erfüllt sync.WaitGroup?
sync.WaitGroup ermöglicht es Ihnen, auf den Abschluss einer Sammlung von Goroutines zu warten. Sie erhöhen den Counter mit Add(), verringern ihn mit Done(), wenn eine Goroutine abschließt, und blockieren mit Wait(), bis der Counter Null erreicht.
Wie erkenne ich Race Conditions in meinem Go-Code?
Führen Sie Ihre Tests oder Binärdateien mit aktiviertem Race-Detector aus, indem Sie 'go test -race ./...' oder 'go run -race main.go' verwenden. Der Race-Detector überwahrt den Speicherzugriff und meldet gleichzeitige Lese-/Schreibzugriffe auf gemeinsamen Speicher ohne Synchronisation.
Was ist der Unterschied zwischen gepufferten und ungepufferten Channels?
Ungepufferte Channels (make(chan T)) erfordern, dass sowohl Sender als auch Empfänger gleichzeitig bereit sind, und bieten Synchronisation. Gepufferte Channels (make(chan T, n)) können bis zu n Werte ohne Empfänger halten, sodass Sender fortfahren können, bis der Puffer voll ist.

Entwicklerdetails

Autor

sickn33

Lizenz

MIT

Repository

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

Ref

main

Dateistruktur

📁 resources/

📄 implementation-playbook.md

📄 SKILL.md