Skip to content

Modul 7: Concurrency: Goroutines, Channels & Context

Nebenläufigkeit in Go von Grund auf: Goroutinen und das go-Statement, ungepufferte und gepufferte Channels, select mit Timeouts, context.Context, das sync-Paket sowie Worker-Pools und Fan-out/Fan-in-Pipelines.

Fortschritt0/5 Lektionen
31

Goroutinen & das 'go'-Statement: Scheduling & Leaks

Lektion 31 von 100

Ein Preisvergleich mit Sekundenbudget

Stellen wir uns einen Preisvergleichsdienst vor: Für jede Suchanfrage müssen zwölf Händler-APIs befragt werden, und jede Antwort braucht rund 250 Millisekunden. Wer nacheinander fragt, landet bei etwa drei Sekunden pro Suche — für Nutzer eine Ewigkeit, und dabei verbringt der Code die meiste Zeit nicht mit Rechnen, sondern mit Warten auf I/O. Genau für diese Klasse von Problemen wurde Go gebaut: Wir starten zwölf Abfragen praktisch gleichzeitig und verarbeiten jede Antwort, sobald sie eintrifft. Die Gesamtdauer schrumpft auf die der langsamsten einzelnen Antwort.

Nebenläufigkeit ist die Unterschrift von Go — kein anderes Feature prägt Sprache und Ökosystem so sehr. In diesem Modul bauen wir das Fundament in fünf Lektionen: heute Goroutinen, danach Channels, select und context.Context, das sync-Paket und zum Abschluss Worker-Pools und Pipelines. Wer Modul 4 nebenläufige AI-Pipelines mit errgroup gelesen hat, wird hier die Bausteine im Detail nachholen.

Das go-Statement: ein Wort, eine eigene Ausführung

Eine Goroutine startet man, indem man der Funktionsaufruf-Expression schlicht das Schlüsselwort go voranstellt. Das ist alles — keine Thread-Erzeugung, kein Executor, kein async/await. Ab diesem Moment läuft die Funktion neben dem aufrufenden Code weiter; die Runtime kümmert sich darum, wann und wo sie tatsächlich Prozessorzeit bekommt.

package main

import (
	"fmt"
	"time"
)

func gruss(name string) {
	fmt.Println("Hallo aus", name)
}

func main() {
	go gruss("Alpha") // startet und läuft neben main her
	go gruss("Beta")

	fmt.Println("main läuft sofort weiter")

	// shortcut: Sleep nur für dieses Demo. Echte Synchronisation
	// lernen wir mit Channels (Lektion 32) und WaitGroup (Lektion 34).
	time.Sleep(50 * time.Millisecond)
	// → main läuft sofort weiter
	// → Hallo aus Alpha
	// → Hallo aus Beta   (die Reihenfolge der beiden ist nicht garantiert)
}

Beachte die Ausgabereihenfolge: main druckt zuerst, obwohl die Goroutinen längst gestartet wurden. Der Scheduler entscheidet frei, wann jede Goroutine Prozessorzeit erhält — Nebenläufigkeit bedeutet bewusst Unbestimmtheit in der Reihenfolge.

Goroutinen sind keine Betriebssystem-Threads

Eine Goroutine ist eine verwaltete Ausführung der Go-Runtime mit einem winzigen Startstack von nur wenigen Kilobyte, der bei Bedarf wächst. Die Runtime verteilt Goroutinen im M:N-Verfahren auf wenige Betriebssystem-Threads — deshalb kann ein Go-Programm problemlos Hunderttausende Goroutinen führen, wo echte Threads längst am Speicherlimit wären. Rob Pikes Merksatz dazu: Concurrency is not parallelism — Nebenläufigkeit ist eine Strukturierung des Programms, Parallelität nur eine mögliche Ausführungsform davon.

Was der Scheduler wirklich macht

Go modelliert das Scheduling mit drei Bausteinen: G (Goroutine), M (Machine, ein Betriebssystem-Thread) und P (Processor, ein Ausführungskontext mit lokaler Lauf queue). Eine Goroutine läuft nur, wenn ihre G an ein M gebunden wird, das einen P hält. GOMAXPROCS legt fest, wie viele P — und damit wie viele Goroutinen tatsächlich parallel rechnen — es gibt; der Default ist die Anzahl der CPU-Kerne, auf Linux-Containern seit Go 1.25 zudem respektvoll gegenüber cgroup-CPU-Limits.

Bis Go 1.13 galt: Wer in einer engen Schleife rechnet und nie einen Synchronisationspunkt erreicht, konnte andere Goroutinen auf demselben P verhungern lassen. Seit Go 1.14 entzieht der Scheduler solchen Goroutinen aktiv die Kontrolle (asynchrone Preemption). Für den Alltag heißt das: Wir dürfen Goroutinen als kostengünstig und fair behandeln — die Runtime regelt die Details.

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Println("CPUs sichtbar:", runtime.NumCPU())
	fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0)) // 0 = nur lesen, nichts setzen
	fmt.Println("Goroutinen im Spiel:", runtime.NumGoroutine())
	// → CPUs sichtbar: 12
	// → GOMAXPROCS: 12
	// → Goroutinen im Spiel: 1
}

Goroutine-Leaks: die stille Speicherfalle

Nebenläufigkeit hat eine Schattenseite: Eine Goroutine, die nie endet, wird nie aufgeräumt. Der klassische Fall ist ein Muster, das wir in Modul 4 schon bei errgroup gestreift haben — „nimm das erste Ergebnis". Zwei Abfragen starten, das schnellere Ergebnis verwenden, das langsamere verwerfen. Klingt harmlos, hat aber eine Kehrseite, die wir uns konkret ansehen:

func abfragen(quelle string, dauer time.Duration) string {
	time.Sleep(dauer) // simulierte Netzwerklatenz
	return quelle + ":Treffer"
}

func erstesErgebnis() string {
	ch := make(chan string) // ungepuffert

	go func() { ch <- abfragen("cache", 15*time.Millisecond) }()
	go func() { ch <- abfragen("datenbank", 3*time.Second) }()

	return <-ch // nur der Gewinner wird je empfangen
}

func main() {
	start := time.Now()
	fmt.Println(erstesErgebnis())
	fmt.Println("Dauer:", time.Since(start).Round(time.Millisecond))
	fmt.Println("Goroutinen danach:", runtime.NumGoroutine())
	// → cache:Treffer
	// → Dauer: 16ms
	// → Goroutinen danach: 2   (main + der unterlegene Datenbank-Abruf)
}

Das Problem: Der Verlierer schläft drei Sekunden, will dann sein Ergebnis in einen Kanal senden, den niemand mehr liest — und blockiert dafür immer und ewig. Die Goroutine leakt. In einem einmaligen Programm fällt das nicht auf, weil das Prozessende aufräumt. In einem Server, der diesen Code pro Anfrage ausführt, wächst die Goroutine-Anzahl mit jedem Request, und mit ihr Speicher und Datei-Handles. Leaks findet man mit runtime.NumGoroutine() in Tests (Zahl muss nach dem Test wieder auf dem Ausgangswert sein) oder mit net/http/pprof im laufenden Betrieb.

Die saubere Lösung — Abbruch über context.Context — bauen wir in Lektion 33; sie wird genau dieses Muster heilen.

⚠ Häufiger Fehler: go f() startet keine „Hintergrundarbeit, die irgendwann fertig wird und deren Ergebnis schon da ist". Kehrt main zurück, beendet die Runtime sofort den gesamten Prozess — noch laufende Goroutinen werden kommentarlos abgeschossen, ob sie fertig sind oder nicht. Ein time.Sleep im Hauptprogramm ist keine Synchronisation, nur ein Zufallsprodukt, das auf schnellen Maschinen zufällig meist funktioniert.

✅ Wichtige Erkenntnisse

Haken setzen, um deinen Lernfortschritt zu markieren:

    32

    Ungepufferte & gepufferte Channels: Abschied von Data Races

    Lektion 32 von 100

    Das letzte Ticket, zweimal verkauft

    Ein Ticketshop am Veranstaltungsabend: Hundert Anfragen laufen parallel ein, alle wollen eines der letzten Hundert Kontingente. Die naive Umsetzung — alle Goroutinen bearbeiten dieselbe Variable — ist der kürzeste Weg ins Datenchaos. Sehen wir uns den Mechanismus am nackten Zähler an; jedes verkaufbar-- im Ticketshop sieht exakt so aus:

    zaehler := 0 // zehn Goroutinen erhöhen je 1000-mal — erwartet: 10000
    
    for i := 0; i < 10; i++ {
    	go func() {
    		for j := 0; j < 1000; j++ {
    			zaehler++ // lesen-ändern-schreiben: KEIN unteilbarer Schritt
    		}
    	}()
    }
    time.Sleep(100 * time.Millisecond) // shortcut: nur fürs Demo
    fmt.Println("gezählt:", zaehler)
    // → gezählt: 9768   (erwartet: 10000 — oft sieht das Ergebnis korrekt aus,
    //                    und genau deshalb überlebt so ein Bug den Testlauf;
    //                    `go run -race` meldet ihn eindeutig: WARNING: DATA RACE)
    

    Ein zaehler++ sieht atomar aus, ist aber drei Schritte: lesen, erhöhen, zurückschreiben. Zwei Goroutinen lesen denselben Wert, beide schreiben ihr Ergebnis zurück, ein Update verschwindet spurlos — im Ticketshop heißt das: dasselbe letzte Ticket wird zweimal verkauft. Perfide ist die Tarnung: In vielen Läufen stimmt das Ergebnis zufällig, deshalb fällt der Race im Testbetrieb selten auf. Der Race-Detektor (go test -race ./...) meldet solche Zugriffe dagegen bereits beim ersten gleichzeitigen Zugriff. Go bietet zwei ehrliche Auswege: Schutz durch Sperren (Lektion 34) — oder den eleganteren, dem wir heute folgen: Zustand gehört genau einer Goroutine, alle anderen stellen Anfragen über Channels. Das Go-Proverb dazu: „Don't communicate by sharing memory; share memory by communicating."

    Ungepufferte Channels: ein Rendezvous

    Ein Channel ist ein typisierter Kanal, über den Goroutinen Werte austauschen. Die Variante ohne Puffer ist streng: Ein Senden blockiert, bis ein Empfänger gleichzeitig bereit ist — und umgekehrt. Senden und Empfangen bilden einen echten Synchronisationspunkt; beim Übergabezeitpunkt sind sich beide Seiten garantiert auf dem gleichen Stand.

    package main
    
    import "fmt"
    
    func main() {
    	zahlen := make(chan int) // ungepuffert: kein Platz zum Parken
    
    	go func() {
    		for i := 1; i <= 3; i++ {
    			fmt.Println("gesendet:      ", i)
    			zahlen <- i // wartet, bis die Gegenseite empfängt
    		}
    		close(zahlen) // der Sender schließt — beendet unten die range-Schleife
    	}()
    
    	for z := range zahlen {
    		fmt.Println("empfangen:     ", z)
    	}
    	// → gesendet:       1
    	// → empfangen:      1
    	// → gesendet:       2
    	// → empfangen:      2
    	// → gesendet:       3
    	// → empfangen:      3
    	// (typischer Lauf — garantiert ist nur „gesendet i“ vor „empfangen i“,
    	//  nicht die strikte Abwechslung der Zeilen)
    }
    

    Die Ausgabe zeigt das Rendezvous — und zugleich seine Grenzen: Zu jedem Wert erscheint gesendet vor empfangen, mehr aber nicht. Auch eine Ausgabe wie gesendet: 2 vor empfangen: 1 ist völlig legal, denn nach jeder Übergabe laufen beide Seiten wieder parallel; synchronisiert ist allein der Übergabezeitpunkt selbst. Streng genommen sichert der Kanalübergang sogar eine Happens-before-Beziehung — alles, was der Sender vor der Übergabe geschrieben hat, ist beim Empfänger nach der Übergabe sicher sichtbar. Und close ist die höfliche Art zu signalisieren: „Es kommt nichts mehr." Eine range-Schleife endet daraufhin sauber; ein einzelner Empfang meldet das Ende über den zweiten Rückgabewert (wert, offen := ... mit offen == false).

    Gepufferte Channels: ein FIFO mit Stauraum

    Mit Kapazitätsangabe wird der Kanal zum gepufferten FIFO: Senden blockiert nur, wenn der Puffer voll ist; Empfangen nur, wenn er leer ist. Das entkoppelt die Seiten zeitlich — genau das brauchten wir in Modul 4, als Worker ihre Ergebnisse in einen Kanal mit len(texts) Puffer schrieben.

    puffer := make(chan string, 2) // Platz für zwei Werte
    
    puffer <- "erst"  // passt in den Puffer, kein Empfänger nötig
    puffer <- "zweit" // Puffer ist jetzt voll
    
    fmt.Println("belegt:", len(puffer), "von", cap(puffer))
    // → belegt: 2 von 2
    
    fmt.Println(<-puffer) // FIFO: zuerst hinein, zuerst heraus
    fmt.Println(<-puffer)
    // → erst
    // → zweit
    

    Eigentum statt Schlösser

    Der Kanal-Gedanke ersetzt Sperren durch Besitzregeln: Ein Wert, der über einen Channel übergeben wird, wechselt das Eigentum. Nur die empfangende Goroutine darf ihn anfassen — dadurch ist kein Mutex nötig, und Data Races sind strukturell ausgeschlossen, nicht nur durch Disziplin verhindert. Puffergröße ist dabei ein Designmittel: Kapazität 0 erzwingt Rendezvous, Kapazität n erlaubt bursts und entkoppelt Taktzeiten.

    Der Zähler mit Eigentümer: der Ticketshop, korrekt

    Zurück zu unserem Ticketshop. Statt dass hundert Goroutinen dieselbe Variable anfassen, besitzt genau eine Goroutine den Kontingent-Stand. Alle anderen senden Anfragen über einen Kanal und erhalten die Antwort über ihren eigenen Rückkanal — ein Muster, das in Go-Quellcodes überall anzutreffen ist:

    type anfrage struct {
    	anzahl  int
    	antwort chan bool
    }
    
    func kontingentVerwalter(anfragen chan anfrage) {
    	verkaufbar := 100 // NUR diese Goroutine fasst verkaufbar an
    	for a := range anfragen {
    		ok := a.anzahl <= verkaufbar
    		if ok {
    			verkaufbar -= a.anzahl
    		}
    		a.antwort <- ok
    	}
    }
    
    func main() {
    	anfragen := make(chan anfrage)
    	go kontingentVerwalter(anfragen)
    
    	kaufen := func(n int) bool {
    		a := anfrage{anzahl: n, antwort: make(chan bool)}
    		anfragen <- a
    		return <-a.antwort
    	}
    
    	fmt.Println(kaufen(60), kaufen(60), kaufen(20))
    	// → true false true
    }
    

    Kein Lock, kein Flag, und trotzdem kann kein Doppelverkauf passieren — alle Entscheidungen laufen serialisiert durch den einen Verwalter. Ehrlicherweise: Für einen simplen Zähler wäre ein sync.Mutex aus Lektion 34 weniger Zeremonie. Channels lohnen sich, wenn Besitz übergeben wird, mehrere Parteien koordiniert werden oder eine Pipeline entsteht — beides sehen wir in Lektion 35 in groß.

    ⚠ Häufiger Fehler: close ist ausschließlich Sache des Senders. Wer aus der Empfangsseite heraus schließt, ein zweites Mal schließt oder auf einen bereits geschlossenen Kanal sendet, erntet eine Panic — und die fällt in Produktion meist weit weg vom eigentlichen Verursacher. Der Empfänger erkennt das Kanalende sicher über den zweiten Rückgabewert des Empfangs oder darüber, dass range einfach endet.

    ✅ Wichtige Erkenntnisse

    Haken setzen, um deinen Lernfortschritt zu markieren:

      33

      select, Timeout-Patterns & context.Context

      Lektion 33 von 100

      Der ungeduldige Nutzer

      Ein Aggregator-Dienst befragt für jede Suche zwei Mirrors derselben Datenquelle — mal ist der eine schneller, mal der andere. Der Nutzer wartet aber maximal eine halbe Sekunde, danach will er einen Fallback sehen. Und wenn er die Seite längst geschlossen hat, sollen auch die letzten Hintergrundabrufe aufhören, sinnlos Ressourcen zu verbrennen. Beides — „das erste gewinnt" und „abbrechen, alle" — lösen wir in dieser Lektion mit select und context.Context.

      select: der Verkehrspolizist an der Kreuzung

      select wartet auf mehrere Kanal-Operationen gleichzeitig und führt genau den Case aus, dessen Operation als erste bereit ist. Die Syntax erinnert an switch, aber die Semantik ist eine andere: Die Cases sind keine Alternativen derselben Variable, sondern konkurrierende Ereignisse. Der wichtigste Baustein ist time.After: Es liefert einen Kanal, der nach Ablauf der Dauer genau einen Wert liefert — der perfekte Timer in einer select-Welt.

      func abfragen(name string, dauer time.Duration) chan string {
      	ch := make(chan string, 1) // Puffer 1: Ergebnis geht nie verloren, egal wie das Rennen ausgeht
      	go func() {
      		time.Sleep(dauer)
      		ch <- name + ":OK"
      	}()
      	return ch
      }
      
      func main() {
      	spiegelA := abfragen("mirror-a", 80*time.Millisecond)
      	spiegelB := abfragen("mirror-b", 200*time.Millisecond)
      
      	select {
      	case a := <-spiegelA:
      		fmt.Println("gewonnen:", a)
      	case b := <-spiegelB:
      		fmt.Println("gewonnen:", b)
      	case <-time.After(500 * time.Millisecond):
      		fmt.Println("Timeout: beide Mirrors zu langsam")
      	}
      	// → gewonnen: mirror-a:OK
      }
      

      Zwei Details verdienen Aufmerksamkeit. Erstens: Sind mehrere Cases gleichzeitig bereit, wählt die Runtime pseudo-zufällig einen — diese Fairness verhindert, dass ein dominanter Kanal die anderen verhungern lässt. Zweitens: Der unterlegene Abruf läuft still weiter; erst sein Puffer von 1 verhindert, dass er zum Leak aus Lektion 31 wird, denn sein Ergebnis kann ungestraft in den gepufferten Kanal einsickern und mit ihm sterben. Wer alle Beteiligten sauber stoppen will, braucht mehr als ein Timeout — er braucht Abbruch.

      Done() ist ein Broadcast

      Ein geschlossener Kanal ist für alle Empfänger sofort und dauerhaft „bereit": Jeder Empfang darauf kehrt sofort mit dem Nullwert zurück. context.Context baut exakt darauf: ctx.Done() liefert einen Kanal, der genau dann geschlossen wird, wenn der Kontext abgebrochen wird oder seine Deadline erreicht. Ein einziges close weckt damit jede Goroutine, die in einem select auf Done() wartet — Abbruch als Rundruf statt Kaskade von Einzelsignalen.

      context.Context: Abbruch als Teil der Signatur

      Ein context.Context trägt drei Dinge durch den Aufrufgraphen: ein Abbruchsignal, eine Deadline und Anfragedaten (z. B. Trace-IDs). Die Konvention ist im ganzen Go-Ökosystem dieselbe: ctx ist das erste Argument einer Funktion, und Werte werden von außen nach innen weitergereicht, nie in Structs gespeichert. Erzeugt werden Contexte als Baum: context.Background() ist die Wurzel, WithCancel und WithTimeout leiten Kinder ab, und ein Abbruch propagiert zu allen Nachfahren.

      func worker(ctx context.Context, name string) chan string {
      	ch := make(chan string, 1)
      	go func() {
      		select {
      		case <-time.After(150 * time.Millisecond): // simulierte Arbeit
      			ch <- name + ":fertig"
      		case <-ctx.Done(): // Abbruch oder Deadline — Rundruf an alle Wartenden
      			ch <- name + " bricht ab: " + ctx.Err().Error()
      		}
      	}()
      	return ch
      }
      
      func main() {
      	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
      	defer cancel() // Pflicht: gibt Timer und Kontexteinträge sofort frei
      
      	fmt.Println(<-worker(ctx, "crawler"))
      	// → crawler bricht ab: context deadline exceeded
      }
      

      Der worker muss dazu kooperativ sein: Nebenläufigkeit in Go zu stoppen ist immer eine Kooperation, kein erzwungener Kill. Der Worker prüft — idealerweise in jedem wartenden select und in jeder Schleifeniteration — ob der Kontext noch lebt, und räumt bei Abbruch selbst auf. ctx.Err() liefert dabei die Ursache (context.DeadlineExceeded oder context.Canceled).

      Damit lässt sich auch das Leck aus Lektion 31 wirklich heilen: Der Verlierer des Rennens bekommt denselben Kontext, bemerkt über ctx.Done() den Abbruch und kehrt kontrolliert zurück, statt ewig auf einen Empfänger zu warten. In Lektion 35 werden wir genau dieses Zusammenspiel im Worker-Pool wiederfinden — und in der Praxis läuft der komplette HTTP-Stack von Go darauf: http.NewRequestWithContext bricht Netzwerkabrufe ab, sobald der Kontext endet.

      ⚠ Häufiger Fehler: context.WithTimeout und WithCancel liefern eine cancel-Funktion zurück, die sofort mit defer cancel() aufgerufen gehört — auch wenn die Deadline das Problem „eh lösen würde". Ohne cancel hält der Kontext seinen Timer und interne Einträge bis zum natürlichen Ablauf fest; in langlaufenden Servern summieren sich diese Lecks über Millionen Requests. go vet meldet ein vergessenes cancel übrigens als lostcancel.

      ✅ Wichtige Erkenntnisse

      Haken setzen, um deinen Lernfortschritt zu markieren:

        34

        sync-Paket: WaitGroup, Mutex, Once

        Lektion 34 von 100

        Nicht alles ist ein Channel

        Ein Metrik-Dienst sammelt Zähler von zweihundert Endpunkten: inkrementiert wird bei jedem Request, gelesen einmal pro Sekunde für das Dashboard. Das ließe sich mit einem besitzenden Verwalter-Goroutine aus Lektion 32 bauen — aber für einen geschützten Wert ist das Zeremonie. Go hat nie behauptet, Sperren seien verboten; das Proverb empfiehlt Kanäle nur als erstes Werkzeug. Das sync-Paket liefert die drei Klassiker, die jede Go-Toolbox enthält: WaitGroup fürs Warten, Mutex für geschützten Zustand, Once für einmalige Initialisierung.

        sync.WaitGroup: ein Zähler fürs Warten

        Das Muster kennen wir im Prinzip schon aus errgroup in Modul 4: vor jedem Start Add(1), in der Goroutine defer Done(), und das Hauptprogramm wartet mit Wait(), bis der Zähler auf null gefallen ist. Bemerkenswert an WaitGroup ist, was sie nicht kann: Sie transportiert keine Werte und keine Fehler — das bleibt Channels überlassen. Seit Go 1.25 gibt es mit wg.Go(f) eine Abkürzung, die Add(1) und Done() automatisch koppelt.

        package main
        
        import (
        	"fmt"
        	"strings"
        	"sync"
        )
        
        func main() {
        	urls := []string{"go.dev", "pkg.go.dev", "blog.golang.org"}
        	funde := make([]string, len(urls))
        
        	var wg sync.WaitGroup
        	for i, url := range urls {
        		wg.Add(1) // VOR dem Start — niemals innerhalb der Goroutine
        		go func(i int, url string) {
        			defer wg.Done()
        			funde[i] = strings.ToUpper(url) // jeder Index separat: kein Konflikt
        		}(i, url)
        	}
        	wg.Wait() // blockiert, bis der Zähler wieder null ist
        
        	fmt.Println(funde)
        	// → [GO.DE PKG.GO.DE BLOG.GOLANG.ORG]
        }
        

        Nebenbei: Dass hier jede Goroutine in ihr eigenes Slice-Element schreibt, ist legal — verschiedene Speicherstellen, kein Konflikt, kein Race. Das explizite Weiterreichen von i und url an die Closure ist seit Go 1.22 nicht mehr zwingend nötig (Schleifenvariablen sind seitdem pro Iteration neu), aber in älteren Codebases allgegenwärtig und daher lesbar geblieben.

        sync.Mutex und sync.RWMutex: Schlösser für Zustand

        Für den Metrik-Dienst ist ein Mutex die ehrliche Antwort: eine Sperre, die garantiert, dass immer nur eine Goroutine den kritischen Abschnitt betritt. Die Regeln sind kurz: so spät wie nötig sperren, so früh wie möglich wieder freigeben — und bei mehreren Methoden auf demselben Zustand schützt dieselbe Sperre alle. RWMutex verfeinert das für lesestarke Profile: beliebig viele Leser gleichzeitig, Schreiber exklusiv. Unter schreiblastiger Konkurrenz ist RWMutex allerdings teurer als ein schlichter Mutex — kein Reflex, sondern abwägen.

        type Zaehler struct {
        	mu    sync.Mutex
        	werte map[string]int
        }
        
        func (z *Zaehler) Inc(name string) {
        	z.mu.Lock()
        	defer z.mu.Unlock()
        	z.werte[name]++
        }
        
        func (z *Zaehler) Snapshot() map[string]int {
        	z.mu.Lock()
        	defer z.mu.Unlock()
        	kopie := make(map[string]int, len(z.werte))
        	for k, v := range z.werte {
        		kopie[k] = v
        	}
        	return kopie // Kopie statt Referenz: aufrufer bekommt keinen Blick auf ungeschützten Zustand
        }
        
        func main() {
        	z := &Zaehler{werte: make(map[string]int)}
        	var wg sync.WaitGroup
        	for i := 0; i < 100; i++ {
        		wg.Add(1)
        		go func() {
        			defer wg.Done()
        			z.Inc("requests")
        		}()
        	}
        	wg.Wait()
        	fmt.Println(z.Snapshot())
        	// → map[requests:100]
        }
        

        Beachte das Snapshot-Detail: Es gibt eine Kopie zurück, keine Referenz auf das ungeschützte Original — sonst könnte man die Sperre perfekt umgehen und hinterher unsynchronisiert lesen. Und noch ein Wachhund: Ein Mutex darf nach erster Benutzung nicht kopiert werden; structs mit Sperren werden per Pointer weitergereicht. go vet findet Verstöße mit der copylocks-Regel zuverlässig.

        sync.Once: genau einmal, garantiert

        Datenbank-Pools, Konfigurationsdateien, teure Berechnungen — vieles soll beim ersten Bedarf initialisiert und dann nie wieder angefasst werden. sync.Once kapselt genau diese Garantie, threadsicher und ohne jede Zeremonie:

        var (
        	einmal sync.Once
        	pool   *sqlPool
        )
        
        func Pool() *sqlPool {
        	einmal.Do(func() {
        		pool = &sqlPool{verbindungen: 20}
        		fmt.Println("Pool initialisiert (dieser Satz erscheint genau einmal)")
        	})
        	return pool
        }
        
        func main() {
        	Pool()
        	Pool() // der zweite Aufruf kehrt sofort zurück, ohne die Funktion erneut auszuführen
        }
        // → Pool initialisiert (dieser Satz erscheint genau einmal)
        

        Mutex für Zustand, Channel für Eigentum

        Faustregel für den Werkzeugkasten: Ein Mutex passt, wenn mehrere Goroutinen Zugriff auf denselben geschützten Zustand brauchen (Cache, Zähler, Registry). Ein Channel passt, wenn Werte oder die Verantwortung dafür übergeben werden (Pipelines, Aufgabenverteilung, Ergebnisse). Neither ist falsch — falsch ist nur, zustandslosen Datentransfer hinter Sperren zu verstecken oder heiße Zustände ohne Not über Kanäle zu zirkulieren.

        ⚠ Häufiger Fehler: wg.Add(1) gehört vor das go-Statement, niemals hinein. Andernfalls kann wg.Wait() den Zähler schon bei null sehen, bevor die erste Goroutine ihren Add-Aufruf ausgeführt hat — das Programm beendet sich scheinbar erfolgreich, während Arbeit stillschweigend fehlt. Der Fehler ist ein echter Data Race und wird vom Race-Detektor gemeldet, taucht aber meist erst unter Last auf.

        ✅ Wichtige Erkenntnisse

        Haken setzen, um deinen Lernfortschritt zu markieren:

          35

          Worker-Pools & Fan-out/Fan-in-Pipelines

          Lektion 35 von 100

          Zehntausend Thumbnails, ein Daemon

          Ein Bilderdienst nimmt nachts einen Batch an: 10.000 Uploads, jedes Bild braucht ein Thumbnail. Eine Goroutine pro Bild? „Goroutinen sind doch billig" — ja, aber die Arbeit dahinter ist es nicht: 10.000 gleichzeitige Lesezugriffe auf die Festplatte, 10.000 offene Encoder, dazu ein Downstream-System, das bei 50 parallelen Anfragen dicht macht. Die Lösung ist ein Worker pool mit fester Größe: viele Aufgaben, wenige Arbeiter, ein Kanal als Fließband dazwischen. Und wenn wir schon Fließbänder haben, können wir sie auch in Stufen zusammenschalten — zur Pipeline mit Fan-out und Fan-in.

          Der Worker-Pool

          Das Rezept hat vier Zutaten: einen Jobs-Kanal, einen Ergebnisse-Kanal, N Goroutinen, die in einer range-Schleife über Jobs arbeiten, und ein sync.WaitGroup, das meldet, wann alle Arbeiter fertig sind. Das Schließen der Kanäle folgt den Regeln aus Lektion 32: Der Einspeiser schließt die Jobs, und die Ergebnisse werden erst geschlossen, wenn der letzte Arbeiter fertig ist — dafür das Wait vor dem close.

          package main
          
          import (
          	"fmt"
          	"sync"
          )
          
          func main() {
          	const anzahlJobs = 6
          	const anzahlWorker = 2
          
          	jobs := make(chan int, anzahlJobs)       // Puffer: Erzeuger blockiert nie beim Einspeisen
          	ergebnisse := make(chan string, anzahlJobs) // Puffer: Worker blockieren nie beim Ablegen
          
          	var wg sync.WaitGroup
          	for w := 1; w <= anzahlWorker; w++ {
          		wg.Add(1)
          		go func(id int) {
          			defer wg.Done()
          			for job := range jobs { // Schleife endet, sobald jobs geschlossen ist
          				ergebnisse <- fmt.Sprintf("Worker %d hat Job %d erledigt", id, job)
          			}
          		}(w)
          	}
          
          	for j := 1; j <= anzahlJobs; j++ {
          		jobs <- j
          	}
          	close(jobs) // alle Aufgaben verteilt → Sender schließt
          
          	wg.Wait()
          	close(ergebnisse) // erst jetzt ist sicher: kein Arbeiter schreibt mehr
          
          	for e := range ergebnisse {
          		fmt.Println(e)
          	}
          	// → Worker 1 hat Job 1 erledigt
          	// → Worker 2 hat Job 2 erledigt
          	// → Worker 1 hat Job 3 erledigt
          	// → ... Zuordnung von Jobs zu Workern und Reihenfolge variieren
          }
          

          Die Puffer sind hier bewusst gewählt: Der Jobs-Puffer anzahlJobs erlaubt dem Einspeiser, alle Aufgaben loszuwerden, ohne auf Arbeiter zu warten; der Ergebnisse-Puffer verhindert, dass Arbeiter beim Ablegen blockieren, während wg.Wait() auf sie wartet — dieselbe Deadlock-Falle, die wir in Modul 4 bei errgroup besprochen haben. In Produktion ersetzt man die fixe Job-Anzahl durch eine Schleife über die echten Aufgaben und verbindet select mit ctx.Done() aus Lektion 33 für sauberes Herunterfahren.

          Gegendruck statt Drossel

          Ein begrenzter Worker-Pool mit begrenzten Puffern erzeugt automatisch Gegendruck (Backpressure): Sind alle Worker beschäftigt und der Jobs-Puffer voll, blockiert der Einspeiser — das System verlangsamt den Zustrom, statt sich selbst zu überlasten. Kein Rate-Limiter, keine Verwurfs-Logik: Die Blockier-Semantik der Kanäle aus Lektion 32 ist die Drossel.

          Fan-out/Fan-in: Pipelines im Fluss

          Bei langen Verarbeitungsketten ist die leistungsschwächste Stufe der Flaschenhals. Pipelines in Go bestehen aus Stufen, die jeweils einen Kanal lesen und einen Kanal schreiben — und jede Stufe kann selbst wieder parallel sein. Zwei Begriffe gehören dazu: Fan-out bedeutet, mehrere Stufen-Instanzen lesen denselben Eingangskanal (jede Aufgabe landet bei genau einer); Fan-in bedeutet, einen Verteiler, der die Ausgänge mehrerer Instanzen wieder in einem Kanal sammelt.

          func erzeugen(werte ...int) <-chan int {
          	out := make(chan int)
          	go func() {
          		defer close(out)
          		for _, w := range werte {
          			out <- w
          		}
          	}()
          	return out
          }
          
          func verdoppeln(in <-chan int) <-chan int {
          	out := make(chan int)
          	go func() {
          		defer close(out)
          		for v := range in {
          			out <- v * 2
          		}
          	}()
          	return out
          }
          
          // zusammenfuehren fächert mehrere Quellen auf einen Ausgangskanal zusammen (Fan-in)
          func zusammenfuehren(quellen ...<-chan int) <-chan int {
          	out := make(chan int)
          	var wg sync.WaitGroup
          	for _, quelle := range quellen {
          		wg.Add(1)
          		go func(quelle <-chan int) {
          			defer wg.Done()
          			for v := range quelle {
          				out <- v
          			}
          		}(quelle)
          	}
          	go func() {
          		wg.Wait()   // warten, bis ALLE Quellen versiegt sind
          		close(out)  // erst dann den Sammelkanal schließen
          	}()
          	return out
          }
          
          func main() {
          	eingang := erzeugen(1, 2, 3, 4, 5)
          
          	// Fan-out: zwei verdoppeln-Stufen teilen sich denselben Eingang
          	stufeA := verdoppeln(eingang)
          	stufeB := verdoppeln(eingang)
          
          	// Fan-in: ein Kanal sammelt alle Ergebnisse
          	for v := range zusammenfuehren(stufeA, stufeB) {
          		fmt.Print(v, " ")
          	}
          	fmt.Println()
          	// → 2 4 6 8 10   (jeder Wert genau einmal verdoppelt, Reihenfolge nicht festgelegt)
          }
          

          Das Zusammenspiel aller Lektionen dieses Moduls steckt in diesen Zeilen: Goroutinen als Stufen (31), Kanäle mit Schließ-Disziplin als Übergaben (32), select auf ctx.Done() für Abbruch in jeder Stufe (33) und WaitGroups als Taktgeber fürs Fan-in (34). Genau dieses Muster — vervielfacht um Fehlerbehandlung mit errgroup und Rate-Limiting — war in Modul 4 die nebenläufige AI-Pipeline; jetzt verstehst du jedes Bauteil davon einzeln.

          ⚠ Häufiger Fehler: Der Sammelkanal beim Fan-in darf erst geschlossen werden, wenn wirklich alle Einspeiser fertig sind — deshalb passiert das oben erst nach wg.Wait() in einer eigenen Goroutine. Ein close, das ein Worker selbst aufruft, während eine andere Stufe noch sendet, endet in der Panic „send on closed channel"; und wer das Schließen komplett vergisst, hängt in der range-Schleife des Konsumenten für immer fest.

          ✅ Wichtige Erkenntnisse

          Haken setzen, um deinen Lernfortschritt zu markieren:

            This site uses essential cookies for Stripe payments. No tracking cookies.