Nebenläufigkeit in Go

Goroutines, die nie enden: Leaks in Go finden und vermeiden

Eine Goroutine wird nicht eingesammelt, nur weil niemand mehr auf sie wartet. Sie bleibt, solange sie blockiert, und hält alles fest, worauf sie zeigt. Genau das macht den Speicherbedarf über Tage sichtbar.

KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
Seit 1997 am Markt Kleine Gruppen Präsenz und Live-Online Zertifizierte Trainer

Kurz gesagt

Ein Go-Dienst, dessen Speicherbedarf über Tage steigt und nach einem Neustart wieder unauffällig ist, hat fast immer Goroutines, die auf etwas warten, das nie eintritt. Sie belegen ihren eigenen Stack und halten alles am Leben, worauf sie zeigen, deshalb wächst der Verbrauch stetig statt sprunghaft. Die Ursachen sind eine kurze Liste: ein Sendevorgang ohne Empfänger, ein Empfang aus einem Kanal, der nie geschlossen wird, ein vergessener Abbruch und ein Timer, den niemand stoppt.

Stand dieser Seite: 04.10.2026

01 Worum es geht

Der Verbrauch steigt gleichmäßig, und im Code ist nichts falsch

Das Muster ist unverwechselbar. Der Dienst läuft nach dem Start unauffällig, nach einigen Stunden liegt der Speicherbedarf höher, nach zwei Tagen deutlich höher, und irgendwann räumt die Umgebung den Prozess ab. Ein Neustart setzt alles zurück, weshalb die Sache lange als Betriebsthema gilt. Auffällig ist dabei, dass der Verbrauch gleichmäßig wächst und nicht in Sprüngen, und dass er mit der Zahl der bearbeiteten Anfragen zusammenhängt.

Anders als in Sprachen mit manueller Speicherverwaltung gibt es dabei keinen verlorenen Zeiger. Der Speicher ist nicht unerreichbar, er wird noch benutzt, jedenfalls formal: Eine Goroutine wartet auf einen Kanal. Für die Garbage Collection ist eine laufende Goroutine ein Ausgangspunkt der Erreichbarkeit, also bleibt sowohl ihr eigener Stack bestehen als auch alles, was sie in ihren Variablen festhält. Wenn das ein Anfrageobjekt mit Nutzdaten ist, summiert sich das schnell.

Der Grund, warum solche Stellen so lange unentdeckt bleiben, liegt in den Tests. Fast alle prüfen den erfolgreichen Ablauf, und auf diesem Weg beenden sich die Goroutines ordentlich. Die Blockade entsteht auf dem Fehlerpfad: Eine Funktion kehrt früher zurück, weil ein Aufruf fehlgeschlagen ist, und die vier Goroutines, die ihr Ergebnis in einen ungepufferten Kanal schreiben wollten, warten von diesem Moment an bis zum Ende des Prozesses.

KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt

02 Symptom, Ursache, Lösung

Die Muster, die im Alltag wirklich auflaufen

Sortiert nach dem, was ihr beobachtet. Zu jedem Fall gehört die Eigenschaft der Sprache, aus der er folgt, und der Umbau, der ihn dauerhaft erledigt, statt den Dienst nachts neu zu starten.

Symptom

Nach jeder fehlgeschlagenen Anfrage bleiben mehrere Goroutines zurück, und die Zahl steigt genau mit der Fehlerrate.

Ursache

Das ist das häufigste Muster überhaupt: Mehrere Goroutines schreiben ihr Ergebnis in einen ungepufferten Kanal, die aufrufende Funktion liest die Ergebnisse in einer Schleife und kehrt beim ersten Fehler vorzeitig zurück. Ab diesem Moment gibt es keinen Empfänger mehr, und jeder noch ausstehende Sendevorgang blockiert für immer.

Lösung

Gib dem Kanal eine Kapazität in Höhe der Zahl der Sender, dann kann jede Goroutine ihr Ergebnis ablegen und sich beenden, auch wenn niemand mehr liest. Alternativ leitest du einen Kontext ab, brichst ihn beim vorzeitigen Rücksprung ab und schreibst in jeder Goroutine in eine Auswahl aus Sendevorgang und Abbruchsignal. Beides ist richtig, die erste Variante ist kürzer, die zweite trägt auch, wenn die Zahl der Sender unbekannt ist.

Symptom

Ein Worker, der Aufgaben aus einem Kanal liest, beendet sich beim Herunterfahren nicht, und der Dienst hängt beim Stoppen.

Ursache

Ein Empfang aus einem Kanal blockiert, bis ein Wert kommt oder der Kanal geschlossen wird. Wenn beim Herunterfahren niemand den Kanal schließt, warten die Arbeitsprozesse weiter. Wartet daneben noch eine WaitGroup auf ihr Ende, hängt der gesamte Ablauf, und das sieht im Betrieb aus wie ein Hänger und nicht wie ein Leck.

Lösung

Der Sender schließt den Kanal, nie der Empfänger, denn nur der Sender weiß, wann nichts mehr kommt. Beim Herunterfahren gehört ein ausdrückliches Signal dazu: Kanal schließen oder Kontext abbrechen, dann auf die Zählgruppe warten, und zwar mit einer Obergrenze für die Wartezeit. Ein Empfang in einer Schleife über den Kanal endet beim Schließen von selbst und ist deshalb die einfachere Bauform.

Symptom

Der Verbrauch wächst langsam, aber stetig, auch wenn kaum Anfragen ankommen, und im Profil stehen viele Goroutines im Zusammenhang mit Zeitgebern.

Ursache

Meist ist es eine Goroutine, die in einer Schleife über den Kanal eines Tickers läuft und keinen Ausstieg hat: Sie wacht im Takt auf, tut ihre Arbeit und endet nie, auch wenn die Aufgabe, für die sie gestartet wurde, längst vorbei ist. Der Zeitgeber selbst ist dagegen seit Go 1.23 kein Speicherleck mehr: Nicht gestoppte Timer und Ticker räumt die Garbage Collection ab, sobald niemand mehr auf sie verweist, auch ein in jeder Schleifenrunde neu erzeugtes time.After. Das gilt allerdings nur, wenn das Modul in go.mod mindestens Go 1.23 angibt, sonst bleibt das alte Verhalten, bei dem jeder Zeitgeber bis zu seinem Ablauf bestehen bleibt.

Lösung

Jede Schleife über einen Ticker bekommt einen zweiten Zweig in der Auswahl, der auf das Abbruchsignal hört und die Goroutine beendet. Den Ticker stoppst du trotzdem mit einem aufgeschobenen Aufruf, weil das die Absicht sichtbar macht und auf Modulen mit älterer go-Angabe weiterhin nötig ist. Prüf außerdem, welche Go-Version in go.mod steht, denn erst ab 1.23 gilt das neue Verhalten der Zeitgeber. Wenn die Wartezeit ohnehin an einem Abbruchkontext hängt, ist ein Kontext mit Frist die klarere Formulierung, weil er sich beim Verlassen selbst aufräumt.

Symptom

Ein Aufruf an ein anderes System hängt gelegentlich sehr lange, und die Zahl der Goroutines steigt genau in diesen Zeiträumen.

Ursache

Ein Netzaufruf ohne Frist wartet, solange die Gegenstelle die Verbindung offen hält, und das kann sehr lange sein. Dazu kommt ein zweiter, leiser Fall: Wenn der Response Body nicht vollständig gelesen und anschließend geschlossen wird, bleibt die zugrunde liegende Verbindung samt zugehöriger Goroutine belegt, statt in den Connection Pool zurückzugehen.

Lösung

Gib jedem ausgehenden Aufruf einen Kontext mit Frist, und zwar auf der Ebene, die weiß, wie lange das Warten fachlich vertretbar ist. Setz zusätzlich eine Obergrenze im verwendeten Client, damit ein vergessener Kontext nicht sofort zum Problem wird. Und schließ den Antwortkörper immer mit einem aufgeschobenen Aufruf, auch bei Fehlerantworten, bei denen der Inhalt dich nicht interessiert.

Symptom

Ein abgeleiteter Kontext wird angelegt, aber nie aufgeräumt, und statische Prüfungen melden das.

Ursache

Ein Kontext mit Abbruchmöglichkeit oder mit Frist erzeugt intern Zustand, der erst beim Aufräumen freigegeben wird. Wer die zurückgegebene Aufräumfunktion nicht aufruft, hinterlässt bei jedem Durchlauf einen Eintrag, der am Elternkontext hängen bleibt. Bei einem langlebigen Elternkontext, etwa dem des Dienstes selbst, wächst das über die gesamte Laufzeit.

Lösung

Auf jede Ableitung folgt unmittelbar der aufgeschobene Aufruf zum Aufräumen, ohne Ausnahme, auch wenn der Kontext ohnehin gleich abläuft. Das eingebaute Prüfwerkzeug der Toolchain findet genau diese Stelle und gehört in die CI-Umgebung. Für Gruppen von Goroutines mit gemeinsamem Abbruch nimmst du die entsprechende Hilfsbibliothek, die den Kontext beim ersten Fehler von selbst abbricht.

Symptom

Die Tests sind grün, der Dienst leckt trotzdem, und in der Vorabumgebung ist nie etwas aufgefallen.

Ursache

Getestet wird der erfolgreiche Ablauf, und auf diesem Weg beenden sich alle Goroutines ordentlich. Die Blockade sitzt im Fehlerfall, beim vorzeitigen Abbruch und beim Herunterfahren, und genau diese drei Pfade nimmt selten ein Test. In der Vorabumgebung fällt es nicht auf, weil dort nach jeder Auslieferung neu gestartet wird und der Verbrauch nie lange genug wachsen kann.

Lösung

Nimm eine Bibliothek zur Prüfung auf übrig gebliebene Goroutines und verankere sie einmal je Testpaket. Ergänz gezielt Tests für den Fehlerpfad und für das Herunterfahren. Seit Go 1.25 gibt es dafür zusätzlich ein Paket in der Standardbibliothek, das Tests für nebenläufigen Code in einer abgeschlossenen Blase mit virtueller Zeit ausführt und ausdrücklich abwarten kann, bis alle Goroutines darin blockieren. Genau dieser Zustand ist die Stelle, an der ein Leck sichtbar wird.

03 Was du mitnimmst

Was du danach an einem Nachmittag erledigst

Die Suche ist erstaunlich mechanisch, wenn man die Reihenfolge einhält. Sechs Schritte führen vom Verdacht zur konkreten Codestelle und danach zu einem Test, der den Fall festhält.

Fünf Fragen führen zur blockierten Goroutine

  1. 01 Bleibt die Zahl der Goroutines nach einer Lastspitze dauerhaft höher?
  2. 02 Welche Stacktraces kommen in der zweiten Aufnahme häufiger vor als in der ersten?
  3. 03 Wie lange blockiert die häufigste Gruppe schon, und worauf?
  4. 04 Wer soll diese Goroutine beenden, wenn der Empfänger vorzeitig zurückkehrt?
  5. 05 Hört jeder blockierende Zugriff dort auch auf das Abbruchsignal?

Die Zahl der Goroutines als Messwert führen

Der einfachste verlässliche Indikator ist die laufende Anzahl. Gib sie als Messwert aus und leg sie neben den Speicherverbrauch. Eine Kurve, die nach jeder Lastspitze auf einem höheren Niveau bleibt, statt zurückzugehen, ist der Beleg, und sie unterscheidet ein Leck von einem einfach zu klein bemessenen Dienst.

Zwei Aufnahmen vergleichen statt eine deuten

Nimm das Goroutine-Profil zweimal auf, mit einigen Minuten Abstand und gleicher Last dazwischen. Interessant ist nur, was in der zweiten Aufnahme häufiger vorkommt. Eine einzelne Aufnahme zeigt vor allem die vielen Goroutines, die gerade völlig regulär arbeiten.

Nach Stacktrace gruppieren und die häufigste Stelle lesen

Die ausführliche Fassung des Profils zeigt zu jeder Goroutine den vollständigen Stack und wie lange sie schon blockiert. Gruppiert nach Stacktrace steht die Ursache meist in der obersten Gruppe, mit einer Wartezeit, die deutlich über allem anderen liegt.

Prüfen, wer die Goroutine beenden soll

Für jede gestartete Goroutine muss eine Antwort auf zwei Fragen existieren: Wer beendet sie, und was passiert, wenn der Empfänger vorzeitig verschwindet. Wo diese Antwort fehlt, liegt das Leck, und zwar unabhängig davon, ob es sich bisher gezeigt hat.

Den Abbruch bis nach unten durchreichen

Ein Abbruchkontext ist nur wirksam, wenn er tatsächlich in jedem blockierenden Vorgang berücksichtigt wird. Jeder Kanalzugriff, der länger warten kann, gehört in ein select, das auch auf das Abbruchsignal hört, und jeder abgeleitete Kontext braucht ein defer auf die Aufräumfunktion.

Den Fall in einem Test festhalten

Wenn die Ursache gefunden ist, gehört ein Test dazu, der den Fehlerpfad nimmt und danach prüft, dass keine Goroutine übrig geblieben ist. Ohne diesen Schritt kommt dieselbe Klasse in einem halben Jahr an anderer Stelle zurück, weil der Fehlerpfad wieder niemandem aufgefallen ist.

KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt

Warum eine blockierte Goroutine nicht eingesammelt wird

Eine Goroutine ist billig, aber nicht kostenlos. Sie beginnt mit einem kleinen eigenen Stack, der bei Bedarf wächst, und sie ist für die Garbage Collection ein Ausgangspunkt der Erreichbarkeit. Solange sie existiert, gilt alles, was sie in ihren Variablen hält, als benutzt. Deshalb kostet ein Leck nicht nur den Stack selbst, sondern häufig ein Vielfaches davon an Daten, die daran hängen: ein Anfrageobjekt, ein gelesener Nutzinhalt, ein Puffer.

Zum Vergleich lohnt der Blick auf den Normalfall: Eine Goroutine endet, wenn ihre Funktion zurückkehrt, und danach ist alles frei. Es gibt keine Möglichkeit, sie von außen zu beenden, keinen Abbruch und keinen Aufruf, der sie einsammelt. Das ist eine bewusste Entscheidung der Sprache und die eigentliche Ursache dafür, dass es diese Fehlerklasse gibt: Wer eine Goroutine startet, übernimmt damit die Verantwortung dafür, dass sie auch wieder zurückkehrt.

Blockieren kann sie an drei Stellen: an einem Kanal, an dem niemand mehr liest oder schreibt, an einer Sperre, die nie freigegeben wird, und an einer Bedingungsvariablen, die niemand mehr benachrichtigt. Die Sprache erkennt einen vollständigen Stillstand aller Goroutines und meldet ihn, aber das hilft nur, wenn wirklich alles steht. Ein Dienst, in dem hunderttausend Goroutines warten und der Rest normal weiterläuft, fällt in diese Erkennung nicht hinein.

Wie ihr sie im laufenden Dienst findet

Der erste Messwert ist die Zahl der Goroutines, direkt aus der Laufzeitumgebung abfragbar und in jeder Überwachung darstellbar. Sie ist deshalb so nützlich, weil sie das Problem eindeutig von einem zu klein bemessenen Dienst unterscheidet: Nach einer Lastspitze muss die Kurve wieder auf das Ausgangsniveau zurückgehen. Tut sie das nicht, ist die Diagnose gestellt, und die Fehlersuche kann gezielt beginnen.

Der zweite Schritt ist das Goroutine-Profil. Es gehört zu den fest eingebauten Profilen der Laufzeitumgebung und lässt sich im Betrieb über eine eigene Schnittstelle abrufen, die man in einem internen Dienst ohne großen Aufwand freischalten kann. In der ausführlichen Fassung zeigt es zu jeder Goroutine den vollständigen Stack und die bisherige Wartezeit. Entscheidend ist, zwei Aufnahmen im Abstand zu vergleichen: Was dazugekommen ist, ist der Verdächtige, und der Stacktrace zeigt direkt auf die Zeile.

Seit Go 1.27 gibt es dafür zusätzlich ein eigenes Profil mit dem Namen goroutineleak, das ausdrücklich geleckte Goroutines meldet. In Go 1.26 war es noch ein Experiment, das beim Bauen eingeschaltet werden musste, seit 1.27 ist es allgemein verfügbar, in runtime/pprof und als Endpunkt /debug/pprof/goroutineleak. Die Erkennung nutzt die Erreichbarkeitsanalyse der Garbage Collection und meldet nur Goroutines, die tatsächlich nicht mehr geweckt werden können. Das ist ein starkes Versprechen, hat aber eine Kehrseite: Wenn der Kanal, auf dem gewartet wird, noch von irgendwoher erreichbar ist, etwa als globale Variable, bleibt der Fall unentdeckt.

Die Regeln, die Leaks von vornherein verhindern

Die erste und wichtigste Regel: Wer eine Goroutine startet, muss sagen können, wann sie zurückkehrt. Wenn diese Antwort im Kopf des Autors nicht existiert, existiert sie auch im Code nicht. Praktisch heißt das, für jede gestartete Goroutine einen Beendigungsweg zu benennen, sei es das Ende eines Kanals, ein Abbruchsignal oder eine natürliche Fertigstellung.

Die zweite Regel betrifft blockierende Zugriffe. Jeder Sendevorgang und jeder Empfang, der länger warten kann als eine Anfrage dauern darf, gehört in eine Auswahl, die zusätzlich auf ein Abbruchsignal hört. Ein Kontext, der nur bis zur Hälfte des Aufrufwegs durchgereicht wird, ist dabei ungefähr so nützlich wie gar keiner, denn genau die letzte, blockierende Stelle ist die, auf die es ankommt.

Dazu kommen drei kleinere Gewohnheiten, die viel abfangen. Kanäle werden vom Sender geschlossen, weil nur er weiß, wann nichts mehr kommt. Die Kapazität eines Kanals wird bewusst gewählt und nicht zufällig, denn sie entscheidet darüber, ob ein Sender ohne Empfänger blockiert. Und jeder abgeleitete Kontext bekommt unmittelbar seinen aufgeschobenen Aufruf zum Aufräumen, auch wenn er ohnehin gleich abläuft. Das eingebaute Prüfwerkzeug der Toolchain findet den letzten Punkt zuverlässig, wenn ihr es in der CI-Umgebung laufen lasst.

Im Test finden statt im Betrieb

Der wirksamste einzelne Handgriff ist eine Prüfung auf übrig gebliebene Goroutines am Ende eines Testlaufs. Die verbreitete Bibliothek dafür lässt sich einmal je Testpaket über die zentrale Einstiegsfunktion einhängen und meldet dann jede Goroutine, die nach dem Ende aller Tests noch läuft. Alternativ lässt sie sich für einzelne Tests aktivieren, was allerdings nicht mit parallel ausgeführten Tests zusammengeht.

Seit Go 1.25 gibt es dafür zusätzlich ein Paket in der Standardbibliothek, das aus einem früheren Experiment hervorgegangen ist. Es führt eine Testfunktion in einer abgeschlossenen Blase aus, in der die Zeit virtualisiert ist: Zeitgeber laufen sofort ab, sobald alle Goroutines in der Blase blockieren. Dazu kommt eine Funktion, die genau darauf wartet, dass alle Goroutines der Blase blockiert sind. Damit lassen sich Abläufe mit Wartezeiten in Millisekunden statt in Sekunden testen, und der Zustand, in dem etwas hängt, wird zu einem beobachtbaren Ereignis statt zu einer Zufallsfrage.

Was in beiden Fällen dazugehört, sind Tests für die Pfade, die im Betrieb das Problem machen: der vorzeitige Rücksprung wegen eines Fehlers, der abgebrochene Kontext und das geordnete Herunterfahren. Diese drei Fälle decken den überwiegenden Teil aller Lecks ab, und sie sind schnell geschrieben, sobald die Prüfung auf übrig gebliebene Goroutines einmal eingerichtet ist.

Dazu passende Kurse

Weil sich diese Muster an fremden Beispielen schlecht üben lassen, sind Go-Kurse mit Schwerpunkt Nebenläufigkeit der direktere Weg zu Diensten, die auch nach Tagen noch unauffällig laufen.

Weil fast jedes Leck auf einem Pfad sitzt, den kein Test nimmt, gehören Kurse, in denen Fehlerpfade systematisch geprüft werden zur selben Baustelle.

Stimmen aus den Kursen

Was Teilnehmende über die Kurse in diesem Bereich sagen

Der Kurs war sehr informativ und hilfreich. Ein großes Danke für unseren Kursleiter Klaus Bauer!
Python 3 Grundkurs intensiv
War super. Super ausführlich wurde Wissen über folgende Themen vermittelt: go multithreading, rest, mongodb Anbindung, so wie Desktop Apps (CLI und GUI) und noch weitere Themen.
Go Programmierung - Aufbaukurs (Golang)
Sehr angenehmes Schulungsklima. Der Trainer ging sehr auf unsere speziellen Fragen ein und machte die Schulung daher zu einem vollen Erfolg. Sehr zu empfehlen!
Yocto Intensivkurs (Embedded Linux)

05 Fragen

Häufige Fragen

Deine Frage ist nicht dabei? Stell sie uns direkt, wir antworten dir persönlich.

Wie viele Goroutines sind eigentlich zu viele?
Eine absolute Zahl gibt es nicht, hunderttausend gleichzeitig sind für Go ein völlig normaler Zustand. Aussagekräftig ist allein der Verlauf: Nach einer Lastspitze muss die Kurve wieder auf das Ausgangsniveau zurückgehen. Ein dauerhaft steigender Sockel ist das Signal, unabhängig davon, wie hoch die absolute Zahl gerade steht.
Kann ich eine hängende Goroutine von außen beenden?
Nein, und das ist eine bewusste Entscheidung der Sprache. Es gibt keinen Abbruch von außen, eine Goroutine endet ausschließlich dadurch, dass ihre Funktion zurückkehrt. Deshalb muss der Beendigungsweg beim Starten schon feststehen, in der Regel über einen Kontext, dessen Abbruchsignal in jedem blockierenden Zugriff berücksichtigt wird.
Reicht es, den Kanal einfach zu puffern?
Für den häufigsten Fall ja: Wenn die Zahl der Sender feststeht und der Puffer genauso groß ist, kann jeder sein Ergebnis ablegen und sich beenden, auch wenn niemand mehr liest. Sobald die Zahl der Sender unbekannt ist oder unbegrenzt wachsen kann, verschiebt der Puffer das Problem nur vom Blockieren zum Speicherverbrauch. Dann führt kein Weg an einem ausdrücklichen Abbruch vorbei.
Findet die eingebaute Deadlock-Erkennung solche Fälle?
Nur den Sonderfall, dass wirklich sämtliche Goroutines blockieren. Ein Dienst, in dem einige tausend Goroutines warten und der Rest normal weiterarbeitet, fällt nicht darunter, und genau das ist der praktisch relevante Fall. Deshalb braucht es die Beobachtung im Betrieb oder die Prüfung im Test.
Lohnt sich das neue Profil für geleckte Goroutines schon?
Ja, seit Go 1.27 ist es allgemein verfügbar und die direkteste Antwort auf die Frage. Wer noch mit Go 1.26 baut, muss es dort als Experiment beim Bauen einschalten. Verlassen solltet ihr euch nicht allein darauf, denn es meldet bewusst nur Fälle ohne jeden Zweifel und übersieht deshalb Goroutines, die an einem noch erreichbaren Kanal warten.
Persönlich für dich da

Deine Ansprechpartner

Du bist dir nicht sicher, welcher Kurs oder welches Level zu dir passt? Wir beraten dich persönlich und kostenlos.

Yves Hoppe

Yves Hoppe

Weiterbildung & Beratung

Hilft dir, aus dem Programmierung-Programm den passenden Kurs für deinen Stand zu finden.

Norbert Jansen

Norbert Jansen

Beratung & Inhouse

Plant mit dir Inhouse-Trainings, die auf eure Abläufe und euren Datenbestand zugeschnitten sind.

Nebenläufigkeit in Go an eigenen Diensten üben

Im Go-Kurs zur Nebenläufigkeit bei cmt baust du Kanäle, Kontexte und Arbeitsgruppen von Grund auf und siehst dabei genau die Stellen, an denen eine Goroutine später hängen bleibt.