Skip to content

Modul 20: Performance-Tuning

Go-Programme messbar schneller machen: pprof-Profile für CPU, Heap, Goroutinen und Mutexe richtig lesen, Escape Analysis und die 64-KB-Grenze verstehen, den Garbage Collector mit GOGC und GOMEMLIMIT tunen, Zero-Alloc-Patterns mit sync.Pool, Preallocation und strings.Builder umsetzen — eingebettet in den disziplinierten Optimierungs-Workflow Messen → Verstehen → Fixen → Wiederholen.

Fortschritt0/5 Lektionen
96

pprof beherrschen: CPU, Heap, Goroutine- & Mutex-Profile

Lektion 96 von 100

Ohne Profil ist Optimierung Raten — mit pprof ist sie Messen

Der Black-Friday-Stresstest der Buchhandlung »Kant & Kurve« zeigt es gnadenlos: Unter 500 gleichzeitigen Anfragen steigt die p95-Latenz der Buchsuche von 40 auf über 900 Millisekunden. Wo anfangen? Nicht im Code — bei den Daten. Go bringt mit pprof einen vollwertigen Profiler mit, der direkt in der Runtime steckt: kein externes Tool, kein Agent, kein APM-Vendor. Zwei Pakete reichen: runtime/pprof für Batch-Programme und net/http/pprof für lange laufende Server.

Der Profiling-Endpoint läuft in der Praxis auf einem eigenen Port, der nur im internen Netz erreichbar ist — auch bei einem gRPC-Service (google.golang.org/grpc) legt man einfach einen zweiten net/http-Listener daneben und bedient beide über dasselbe Binary.

// cmd/server/main.go — pprof aktivieren: ein Blank-Import genügt
package main

import (
	"log"
	"net/http"
	_ "net/http/pprof" // registriert /debug/pprof/* im DefaultServeMux
)

func main() {
	// Profiling-Server auf separatem Port — niemals öffentlich exponieren!
	go func() {
		log.Fatal(http.ListenAndServe("localhost:6060", nil))
	}()

	// Der eigentliche Service läuft unberührt auf :8080
	mux := http.NewServeMux()
	mux.HandleFunc("GET /search", handleSearch)
	log.Fatal(http.ListenAndServe(":8080", mux))
}

// Terminal: Übersicht aller verfügbaren Profile abfragen
// $ curl -s http://localhost:6060/debug/pprof/
// → /debug/pprof/
// → profiles:
// → 0	block
// → 37	goroutine
// → 7	heap
// → 0	mutex
// → 5	threadcreate
// → full profile:

Die vier Profile und ihre Aufgaben

Jedes Profil beantwortet eine andere Frage

Das CPU-Profil (/debug/pprof/profile) sampelt ~100-mal pro Sekunde Stacktraces von Goroutinen, die gerade CPU nutzen — es zeigt, wo Rechenzeit verbrannt wird. Das Heap-Profil (heap) zeigt Allokationen (standardmäßig eine Probe je ~512 KB Allokationsvolumen — kleine Objekte sind unterrepräsentiert). Das Goroutine-Profil zählt alle lebenden Goroutines und ist das Leck-Detektor. Die Block- und Mutex-Profile zeigen Wartezeiten auf Kanälen, Locks und sync.WaitGroup — sie müssen vorher per runtime.SetBlockProfileRate bzw. runtime.SetMutexProfileFraction aktiviert werden.

Das CPU-Profil nimmt man typischerweise während realer Last auf — 30 Sekunden unter dem Stresstest sagen mehr als jede Stunde im Leerlauf:

// Terminal: 30 Sekunden CPU-Profil unter Last aufnehmen und auswerten
// $ go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
// → Fetching profile over HTTP from http://localhost:6060/debug/pprof/profile?seconds=30
// → Saved profile in C:\Users\Tobias\pprof\pprof.books.exe.samples.cpu.001.pb.gz
// → Type: cpu
// → Entering interactive mode (type "help" for commands, "o" for options)
// (pprof) top
// → Showing nodes accounting for 2.14s, 89.5% of 2.39s total
// → Dropped 87 nodes (cum <= 0.012s)
// →       flat  flat%   sum%        cum   cum%
// →      1.21s 50.63% 50.63%      1.21s 50.63%  runtime.mallocgc
// →      0.32s 13.39% 64.02%      0.98s 40.92%  bookstore.Index.Lookup
// →      0.28s 11.72% 75.73%      0.28s 11.72%  runtime.mapaccess2_faststr

flat ist die Zeit, die direkt in der Funktion vergeht, cum die Zeit inklusive aller aufgerufenen Funktionen. Hier dominiert runtime.mallocgc — die Allokationsmaschinerie. Das ist der klassische Fingerzeig Richtung Lektion 99. Das interaktive -http=:8080-Flag öffnet zusätzlich einen Flamegraphen im Browser.

Heap- und Goroutine-Profil: Speicher und Lecks

Während das CPU-Profil zeigt, wo Zeit verbraucht wird, zeigt das Heap-Profil, wo Speicher entsteht — entscheidend für GC-Last und Container-Limits:

// Terminal: Wo wird Speicher allokiert? Und leaken Goroutines?
// $ go tool pprof -sample_index=alloc_space http://localhost:6060/debug/pprof/heap
// (pprof) top 3
// → Showing nodes accounting for 118MB, 90.77% of 130MB total
// → Dropped 17 nodes (cum <= 0.65MB)
// →       flat  flat%   sum%        cum   cum%
// →     104.02MB 80.02% 80.02%   104.02MB 80.02%  bookstore.(*Cart).Serialize
// →      14.15MB 10.88% 90.90%    14.15MB 10.88%  encoding/json.Marshal

// $ curl -s "http://localhost:6060/debug/pprof/goroutine?debug=1" | head -4
// → goroutine profile: total 1042
// → 980 @ 0x104a2f 0x104b53 0x12c4d0 0x12c8f1 0x228d90
// → #	0x12c4d0	bookstore.ListenForCartEvents.func1+0x50	cart/events.go:47

980 Goroutines mit identischem Stack in cart/events.go:47 — das ist kein Lastspitzen-Effekt, das ist ein Leck: irgendwo wird eine Goroutine gestartet, deren Channel nie geschlossen wird (wie man solche Lecks mit Kontexten verhindert, stand in Modul 7 bei den Contexts). Für Lock-Konkurrenz schaltet man die beiden Contention-Profile scharf:

// cmd/server/main.go — Block- und Mutex-Profil aktivieren (minimaler Overhead)
package main

import "runtime"

func init() {
	runtime.SetBlockProfileRate(1_000_000) // 1 Probe je 1 ms Blockzeit
	runtime.SetMutexProfileFraction(100)   // ~1 % aller Mutex-Events
}

// Terminal: Wer hält andere auf? Contention-Profil abfragen
// $ go tool pprof http://localhost:6060/debug/pprof/mutex
// (pprof) top
// → Showing nodes accounting for 940ms, 93% of 1010ms total
// →       flat  flat%   sum%        cum   cum%
// →      940ms 93.07% 93.07%      940ms 93.07%  sync.(*Mutex).Unlock
// →         0     0% 93.07%      940ms 93.07%  bookstore.(*Inventory).Reserve

⚠ Häufiger Fehler: Die pprof-Endpoints unbeabsichtigt öffentlich exponieren — wer http.ListenAndServe(":6060", nil) statt localhost:6060 schreibt, stellt Stacktraces, Quellcode-Pfade und im Heap-Dump sogar Kundendaten ins Netz. Immer an localhost oder ein internes Interface binden und per Netzwerk-Policy abschotten. Der zweite Klassiker: das CPU-Profil im Leerlauf aufnehmen und daraus Last-Schlüsse ziehen — 30 Sekunden Profil unter realer Anfrage-Last gehören dazu.

✅ Wichtige Erkenntnisse

Haken setzen, um deinen Lernfortschritt zu markieren:

    97

    Escape Analysis: Stack vs Heap & die 64-KB-Grenze

    Lektion 97 von 100

    Die billigste Allokation ist die, die nie passiert

    Jede Heap-Allokation kostet dreifach: runtime.mallocgc zum Allokalieren, GC-Arbeit beim Aufräumen und Cache-Druck durch Pointer-Chasing. Stack-Allokationen sind dagegen praktisch gratis — der Stack-Pointer wird verschoben, fertig. Der Compiler entscheidet mit der Escape Analysis, wo eine Variable lebt: Bleibt eine Adresse innerhalb des Funktions-Stackframes, bleibt alles auf dem Stack. Kann der Compiler nicht beweisen, dass eine Variable den Frame nie verlässt, „entkommt" sie auf den Heap.

    Im Hot Path der Buchsuche von »Kant & Kurve« fielen in Lektion 96 über 50 % der CPU-Zeit in runtime.mallocgc — bevor wir irgendwas umschreiben, müssen wir verstehen, warum Variablen überhaupt auf den Heap wandern:

    // cmd/escape/main.go — Stack oder Heap? Der Compiler entscheidet.
    package main
    
    import "fmt"
    
    // StackVariante gibt eine Kopie zurück — x bleibt im Stack-Frame
    func StackVariante() int {
    	x := 42
    	return x
    }
    
    // HeapVariante gibt die Adresse einer lokalen Variable zurück
    func HeapVariante() *int {
    	y := 42 // entkommt: der Pointer überlebt den Stack-Frame
    	return &y
    }
    
    func constMake() int {
    	s := make([]int, 8) // konstante, kleine Größe → Stack
    	s[0] = 1
    	return s[0]
    }
    
    func bigConstMake() int {
    	b := make([]byte, 128*1024) // 128 KB — über der impliziten Grenze
    	return len(b)
    }
    
    func varMake(n int) int {
    	b := make([]byte, n) // Größe erst zur Laufzeit bekannt
    	return len(b)
    }
    
    func main() {
    	fmt.Println(StackVariante(), *HeapVariante(), constMake(), bigConstMake(), varMake(64))
    	// → 42 42 1 131072 64
    }
    

    Der Compiler legt seine Entscheidung offen — mit -gcflags direkt und ehrlich (Output unter Go 1.24, bei anderen Versionen minimal anders):

    // Terminal: Escape-Analyse sichtbar machen (-l deaktiviert Inlining für saubere Zuordnung)
    // $ go build -gcflags="-m -l" ./cmd/escape/
    // → ./cmd/escape/main.go:14:2: moved to heap: y
    // → ./cmd/escape/main.go:19:11: make([]int, 8) does not escape
    // → ./cmd/escape/main.go:25:11: make([]byte, 131072) escapes to heap
    // → ./cmd/escape/main.go:30:11: make([]byte, n) escapes to heap
    // → ./cmd/escape/main.go:35:13: ... argument does not escape
    

    Die 64-KB-Grenze und die anderen Grenzwerte

    Die drei Größenregeln der Escape Analysis

    1. Implizite Allokationen (make, Slice-Literale) mit konstanter Größe über 64 KB entkommen auf den Heap — maxImplicitStackVarSize im Compiler cmd/compile. 2. Nicht-konstante Größen wie make([]byte, n) entkommen immer — der Compiler kann keine Obergrenze beweisen. 3. Explizite Variablen über 10 MB gehen grundsätzlich auf den Heap (maxStackVarSize). Die Werte sind Compiler-Implementierungsdetail, gelten aber seit vielen Go-Versionen unverändert.

    Das erklärt die Ausgabe oben: make([]int, 8) bleibt auf dem Stack (klein, konstant, entkommt nicht), make([]byte, 131072) entkommt (128 KB über 64 KB), und make([]byte, n) entkommt trotz n=64 zur Laufzeit — die Größe ist dem Compiler zur Übersetzungszeit unbekannt. Die Konsequenz für den Hot Path: Übergibt man eine bekannte Maximalgröße als Konstante statt als Parameter, kann der Compiler wieder stacken.

    Die klassischen Escape-Fallen

    Neben der Größe sind es drei Muster, die Variablen auf den Heap zwingen — Pointer in escapende Container, Boxing in interface{} (jedes fmt.Println-Argument!) und Adressen, die über Funktionsgrenzen wandern:

    // cmd/escape/traps.go — die drei klassischen Escape-Fallen
    package main
    
    import "fmt"
    
    type Bestellung struct {
    	Positionen []*Position
    }
    
    type Position struct {
    	Titel string
    }
    
    // Falle 1: Pointer in einen Container, dessen Schicksal die Funktion nicht kennt
    func addEscape(b *Bestellung) {
    	p := &Position{Titel: "Go-Buch"} // entkommt: landet in b
    	b.Positionen = append(b.Positionen, p)
    }
    
    // Falle 2: Interface-Boxing — fmt.Println packt jedes Argument in interface{}
    func boxingDemo(s string) {
    	fmt.Println(s) // s entkommt: Wert muss ins Interface-Format konvertiert werden
    }
    
    // Falle 3: nil-Slice mit append — Kapazität unbekannt, wächst in Schritten
    func growDemo(n int) []int {
    	var s []int
    	for i := 0; i < n; i++ {
    		s = append(s, i)
    	}
    	return s
    }
    
    func main() {
    	boxingDemo("Kant & Kurve")
    	b := &Bestellung{}
    	addEscape(b)
    	fmt.Println(len(growDemo(5)), len(b.Positionen))
    	// → 5 1
    }
    
    // Terminal: go build -gcflags="-m -l" ./cmd/escape/
    // → ./cmd/escape/traps.go:16:7: &Position{...} escapes to heap
    // → ./cmd/escape/traps.go:22:14: s escapes to heap
    

    Wichtig für die Einordnung: Escape Analysis ist keine Zauberei, sondern Flussanalyse mit Beweislast beim Compiler. Und Heap ist nicht per se schlecht — manchmal ist ein *Position auf dem Heap genau richtig (Lektion 99 zeigt, wie man die verbleibenden Allokationen billig macht). Wer Escape-Meldungen in CI festnageln will, findet sie auch in go vet-Berichten wieder.

    ⚠ Häufiger Fehler: Glauben, new(T) erzwinge den Heap — oder umgekehrt, ein Wert-Typ bleibe automatisch auf dem Stack. Entscheidend ist nie die Schreibweise, sondern ob die Adresse entkommt: p := new(Position) bleibt auf dem Stack, wenn p den Frame nie verlässt, während &Position{} auf den Heap wandert, sobald der Pointer in einem escapenden Container landet. Wer durchgängig Pointer zurückgibt, um sich Schreibarbeit zu sparen, zahlt in jedem Hot Path GC-Steuern.

    ✅ Wichtige Erkenntnisse

    Haken setzen, um deinen Lernfortschritt zu markieren:

      98

      GC-Tuning: GOGC, GOMEMLIMIT & Live-Heap-Messung

      Lektion 98 von 100

      Der Garbage Collector ist ein Stellrad, kein Blackbox-Los

      Nach Lektion 97 allokieren wir bewusster — aber jedes reale Programm allokiert trotzdem, und dann arbeitet der Garbage Collector. Go setzt auf einen gleichzeitigen (concurrent) Mark-and-Sweep-Collector ohne Generationen: Er markiert lebende Objekte parallel zur Anwendung und stoppt die Welt nur für kurze, meist submillisekundige Phasen. Zwei Regler bestimmen, wie oft er läuft: GOGC (Speicher-gegen-CPU-Tausch) und GOMEMLIMIT (seit Go 1.19, OOM-Schutz in Containern).

      Das Szenario: Der Buchshop läuft in Kubernetes mit einem 512-MiB-Speicherlimit und wird am Black Friday regelmäßig OOMKilled. Bevor irgendwer an Reglern dreht, wird gemessen — mit gctrace:

      // Terminal: GC-Zyklen live beobachten
      // $ GODEBUG=gctrace=1 ./bookstore
      // → gc 3 @3.204s 1%: 0.015+2.1+0.031 ms clock, 0.12+0.53/2.0/0+0.25 ms cpu,
      // →   47->49->25 MB, 50 MB goal, 0 MB stacks, 0 MB globals, 8 P
      

      Die entscheidenden Zahlen sind 47->49->25 MB: Heap-Größe beim Start des Zyklus (47 MB), beim Ende der Mark-Phase (49 MB) und der Live-Heap nach dem Aufräumen (25 MB). 50 MB goal ist das Ziel des nächsten Zyklus — und genau hier greift GOGC.

      GOGC und GOMEMLIMIT in einem Satz

      GOGC (Standard: 100) legt fest: Der nächste GC-Zyklus startet, wenn der Heap auf Live-Heap × (1 + GOGC/100) gewachsen ist — bei 25 MB Live-Heap und GOGC=100 also bei 50 MB. Höherer GOGC = seltenere GCs, weniger CPU, mehr Spitzen-Speicher. GOMEMLIMIT (Go 1.19+) setzt ein weiches Limit für die gesamte runtime-verwaltete Speichermenge (Heap, Stacks, Globals) — der GC läuft dicht daran deutlich häufiger, statt das Container-Limit zu sprengen.

      Live-Heap messen statt schätzen

      Tuning ohne Live-Heap-Zahl ist Stochern im Nebel: Ein Live-Heap von 25 MB bei GOGC=100 pendelt um 50 MB; ein Live-Heap von 300 MB pendelt um 600 MB — kein GOGC der Welt macht aus dem zweiten Fall ein 512-MiB-Budget. Sauber messen lässt sich das zur Laufzeit mit runtime/metrics:

      // internal/gcstats/heap.go — Live-Heap und GC-Ziel programmatisch lesen
      package gcstats
      
      import (
      	"fmt"
      	"runtime/metrics"
      )
      
      // LiveHeapBytes liefert den aktuellen Live-Heap und das nächste GC-Ziel.
      func LiveHeapBytes() (live, goal uint64) {
      	samples := []metrics.Sample{
      		{Name: "/memory/classes/heap/objects:bytes"}, // belegter Heap mit Live-Objekten
      		{Name: "/gc/heap/goal:bytes"},                // Zielgröße des nächsten Zyklus
      	}
      	metrics.Read(samples)
      	return samples[0].Value.Uint64(), samples[1].Value.Uint64()
      }
      
      func main() {
      	live, goal := LiveHeapBytes()
      	fmt.Printf("live=%.0f MB goal=%.0f MB\n", float64(live)/1e6, float64(goal)/1e6)
      	// → live=25 MB goal=50 MB
      }
      

      Die Metrik-Namen sind stabile API — go doc runtime/metrics listet alle, darunter auch /gc/gogc:percent und /gc/gomemlimit:bytes zum Verifizieren der aktiven Regler. Für die entscheidende Frage, wie groß der Live-Heap wirklich wird, gilt: unter Produktionslast messen, nicht im Dev-Loop. Wie sich Speicher- und Latenziele in Gesamt-Architektur übersetzen, ist übrigens kein Go-Thema, sondern Skalierungs-Thema — die Grundlagen dazu stehen in Modul 7: Skalierbarkeit der Architektur-Reihe.

      Die Regler setzen — mit Puffer nach oben

      Erst wenn das Memory-Budget klar ist, wird gedreht. Als Umgebungsvariablen (GOGC=200, GOMEMLIMIT=480MiB) oder programmatisch:

      // cmd/server/main.go — GC-Regler programmatisch setzen
      package main
      
      import "runtime/debug"
      
      func init() {
      	// 512-MiB-Container: Limit mit ~6 % Puffer — das Limit ist weich,
      	// der GC stirbt lieber an eigener CPU-Arbeit als am OOM-Kill
      	debug.SetMemoryLimit(480 << 20)
      	// GOGC bleibt auf Standard 100 — wer ALLE Zyklen eliminieren will,
      	// hat meist ein Live-Heap-Problem (Lektion 97/99), kein GOGC-Problem
      }
      
      // Terminal: nach dem Tuning — der Heap pendelt unter dem Limit
      // $ GODEBUG=gctrace=1 go run ./cmd/server
      // → gc 9 @7.8s 2%: 0.019+2.4+0.051 ms clock, ..., 361->380->190 MB, 380 MB goal, 0 MB stacks, 0 MB globals, 8 P
      

      Typische Recipes: Mehr Durchsatz, RAM vorhanden → GOGC auf 200–500 erhöhen (halbiert bis quintupliert den Abstand zwischen den Zyklen). Container eng → GOMEMLIMIT knapp unter das cgroup-Limit. Kurze CLI-Tools → GOGC=off ist hier legitim, weil der Prozess endet, bevor der GC relevant wird. Und mit debug.FreeOSMemory() gibt man nach einem großen Batch freigewordenen Speicher aktiv ans Betriebssystem zurück.

      ⚠ Häufiger Fehler: GOMEMLIMIT exakt auf das Container-Limit setzen (oder GOGC blind auf 500 erhöhen, weil „weniger GC doch gut ist"). Das Limit ist weich: Der GC beschleunigt zwar kurz vor dem Limit die Zyklen, aber wenn der Live-Heap selbst zu groß ist, dreht er sich im Kreis — die berüchtigte GC-Todes-Spirale mit 80 % CPU in runtime.gcBgMarkWorker und trotzdem steigender Latenz bis zum OOM. Immer 5–10 % Puffer unter dem Container-Limit lassen und zuerst den Live-Heap senken (Lektion 97 und 99), dann erst an GOGC drehen.

      ✅ Wichtige Erkenntnisse

      Haken setzen, um deinen Lernfortschritt zu markieren:

        99

        Zero-Alloc-Patterns: sync.Pool, Preallocation, strings.Builder

        Lektion 99 von 100

        Null Allokationen pro Aufruf — kein Hexenwerk, sondern drei Muster

        Das CPU-Profil aus Lektion 96 zeigte es: Über 50 % Rechenzeit in runtime.mallocgc. Die Buchhaltungs-Endpunkte von »Kant & Kurve« serialisieren pro Anfrage Rechnungstexte — und jede String-Konkatenation mit += allokiert frisch. Das Ziel „Zero Alloc" bedeutet nicht null Allokationen im ganzen Programm, sondern null Allokationen im Hot Path pro Anfrage. Drei Muster decken 90 % der Fälle ab: strings.Builder für Strings, Preallocation für Slices mit bekannter Länge, sync.Pool für wiederverwendbare Puffer-Objekte.

        Muster 1 — strings.Builder mit Grow: Statt bei jedem += einen neuen String zu allokieren, sammelt der Builder in einem internen Byte-Slice, und Grow reserviert den Platz einmal vorab:

        // internal/render/invoice.go — Rechnungszeilen ohne Allokations-Kaskade
        package render
        
        import "strings"
        
        var items = []string{
        	"978-3-423-2089-8", "Der Prozess", "19,90", "Kant & Kurve",
        	"Regal 4", "Zweigstelle Mitte", "Rabatt 3%", "MWSt 7%", "Kunde 4711", "Reserviert",
        }
        
        // InvoiceOld: jede Konkatenation allokiert einen neuen String
        func InvoiceOld() string {
        	s := ""
        	for _, it := range items {
        		s += it + "; "
        	}
        	return s
        }
        
        // InvoiceNew: Grow reserviert vorab, WriteString hängt nur an
        func InvoiceNew() string {
        	var b strings.Builder
        	b.Grow(24 * len(items)) // Obergrenze für den Gesamtbedarf
        	for _, it := range items {
        		b.WriteString(it)
        		b.WriteString("; ")
        	}
        	return b.String()
        }
        
        // Terminal: go test -bench=. -benchmem ./internal/render/
        // → BenchmarkInvoiceOld-10    3015848    403.8 ns/op    760 B/op   10 allocs/op
        // → BenchmarkInvoiceNew-10   12158127    117.9 ns/op    240 B/op    1 allocs/op
        

        3,4-fach schneller — und die Allokationszahlen (10 vs. 1) sind deterministisch, während ns/op je Maschine variieren. Die eine verbleibende Allokation ist der finale String()-Aufruf; sie verschwindet nur, wenn man in einen wiederverwendeten Writer schreibt statt Strings zurückzugeben.

        Muster 2: Preallocation — die Länge kennt man doch schon

        Muster 2 gilt überall dort, wo die Zielgröße bekannt ist: make mit Kapazität statt nil-Slice plus append-Wachstum. Das gilt genauso für Map-Größen (make(map[string]int, n)) und für Vorab-Berechnungen ganzer Batch-Strukturen — auch Datenbanktreiber wie github.com/jackc/pgx/v5 nutzen das Muster intern, etwa wenn pgx.CollectRows mit generischen Row-Mappern die klassischen []any-Boxing-Allokationen vermeidet:

        // internal/inventory/titles.go — eine Allokation statt log-n-facher
        package inventory
        
        import "fmt"
        
        type Book struct {
        	Titel string
        }
        
        // TitelAlt: nil-Slice, append verdoppelt die Kapazität in Schritten
        func TitelAlt(buecher []Book) []string {
        	var titel []string
        	for _, b := range buecher {
        		titel = append(titel, b.Titel) // ~log2(len) Re-Allokationen
        	}
        	return titel
        }
        
        // TitelNeu: Kapazität vorab — genau eine Heap-Allokation
        func TitelNeu(buecher []Book) []string {
        	titel := make([]string, 0, len(buecher))
        	for _, b := range buecher {
        		titel = append(titel, b.Titel)
        	}
        	return titel
        }
        
        func main() {
        	b := []Book{{Titel: "Der Prozess"}, {Titel: "Siddhartha"}}
        	fmt.Println(len(TitelAlt(b)), len(TitelNeu(b)))
        	// → 2 2
        }
        

        Muster 3: sync.Pool — Pufferobjekte wiederverwenden

        Für teure Objekte (Buffer, Encoder, große Slices), die pro Anfrage gebraucht und danach weggeworfen werden, ist sync.Pool das Standardwerkzeug. Der Pool ist GC-bewusst: Bei jedem GC-Zyklus darf er geleert werden — er ist ein Wiederverwendungs-Mechanismus, kein Cache mit Garantie:

        // internal/render/pool.go — Buffers aus dem Pool statt vom Heap
        package render
        
        import (
        	"bytes"
        	"fmt"
        	"io"
        	"sync"
        )
        
        var bufPool = sync.Pool{
        	New: func() any { return bytes.NewBuffer(make([]byte, 0, 4096)) },
        }
        
        // RenderRow schreibt in einen gepoolten Buffer und gibt ihn nach Gebrauch zurück
        func RenderRow(w io.Writer, nr int, titel string) error {
        	buf := bufPool.Get().(*bytes.Buffer)
        	defer func() {
        		buf.Reset() // Pflicht! Alte Inhalte und Kapazität sonst ewig mitgeschleift
        		bufPool.Put(buf)
        	}()
        
        	fmt.Fprintf(buf, "%d. %s\n", nr, titel)
        	_, err := w.Write(buf.Bytes())
        	return err
        }
        
        func main() {
        	var out bytes.Buffer
        	for i, titel := range []string{"Der Prozess", "Siddhartha", "Der Steppenwolf"} {
        		RenderRow(&out, i+1, titel)
        	}
        	fmt.Print(out.String())
        	// → 1. Der Prozess
        	// → 2. Siddhartha
        	// → 3. Der Steppenwolf
        }
        

        Im Verbund mit strconv.AppendInt und strconv.AppendQuote statt fmt.Sprintf lassen sich so ganze Serialisierungspfade auf null Allokationen pro Anfrage drücken — das Muster, das auch die Hot Paths in encoding/json-Alternativen und in gRPC-Marshalling-Bibliotheken (google.golang.org/protobuf) antreibt. Verankert wird das Budget als Test, damit ein Refactor es nicht stillschwiegend sprengt:

        // internal/render/alloc_test.go — Allokations-Budget als Regressionstest
        package render
        
        import "testing"
        
        func TestInvoiceNewAllocBudget(t *testing.T) {
        	allocs := testing.AllocsPerRun(100, func() { InvoiceNew() })
        	if allocs > 1 {
        		t.Fatalf("InvoiceNew braucht %.0f Allokationen, Budget ist 1", allocs)
        	}
        }
        
        // Terminal: go test -run TestInvoiceNewAllocBudget ./internal/render/
        // → ok  bookstore/internal/render  0.012s
        

        ⚠ Häufiger Fehler: Objekte ohne Reset zurück in den Pool legen. bufPool.Put(buf) ohne vorheriges buf.Reset() bedeutet: Der nächste Nutzer bekommt alte Daten — und der Buffer behält seine maximale Kapazität für immer, selbst wenn eine Black-Friday-Spitze ihn einmal auf 4 MB hat wachsen lassen. Das zweite Getötete: winzige Objekte poolen. Für einen 32-Byte-Buffer ist der Pool-Overhead (Lock-freie, aber nicht kostenlose Get/Put-Logik plus Typ-Assertion) teurer als die Allokation selbst — Poolen lohnt sich erst ab Objektkosten im Mikrosekundenbereich oder teuren Initialisierungen.

        ✅ Wichtige Erkenntnisse

        Haken setzen, um deinen Lernfortschritt zu markieren:

          100

          Der Optimierungs-Workflow: Messen → Verstehen → Fixen → Wiederholen

          Lektion 100 von 100

          Der disziplinierte Kreislauf — das Fundament aller Tuning-Arbeit

          Nach dem Black-Friday-Debakel sagt die Geschäftsführung der Buchhandlung: „Macht die Suche schneller." Wo anfangen? Genau hier trennt sich Engineering von Stochern: Der Optimierungs-Workflow ist ein Kreislauf mit vier Schritten — Messen (reproduzierbare Baseline schaffen), Verstehen (Profile lesen, bis der Engpass bewiesen ist), Fixen (den gefundenen Engpass beseitigen, nicht den verdächtigsten Code), Wiederholen (erneut messen, Verbesserung belegen, dann weiter oder stoppen). Alles aus den Lektionen 96 bis 99 — pprof, Escape Analysis, GC-Regler, Zero-Alloc-Patterns — sind Werkzeuge innerhalb dieses Kreislaufs.

          Messen → Verstehen → Fixen → Wiederholen

          Der Kreislauf schützt vor zwei teuren Fehlern: Optimieren ohne Messung (Gefühl statt Beweis) und Optimieren der falschen Stelle (Mikro-Gewinn, während der echte Engpass bleibt). Amdahls Gesetz liefert die harte Mathematik: Macht ein Anteil von 10 % der Laufzeit 100-mal schneller, ist das Gesamtprogramm nur ~9 % schneller. Der Hebel liegt immer beim größten Anteil — und nur die Messung zeigt, wo der liegt.

          Schritt 1: Baseline messen — mit Statistik, nicht mit Einzelwerten

          Benchmarks mit testing.B und -count=10 plus benchstat (aus golang.org/x/perf/cmd/benchstat) machen Verbesserungen belegbar statt behauptet:

          // Terminal: Baseline unter Statistik-Rauschen, Fix, Vergleich
          // $ go test -bench=. -benchmem -count=10 ./internal/search/ | tee alt.txt
          // $ # ... Fix implementieren (siehe Schritt 3) ...
          // $ go test -bench=. -benchmem -count=10 ./internal/search/ | tee neu.txt
          // $ benchstat alt.txt neu.txt
          // →          │  alt.txt   │             neu.txt             │
          // →          │   sec/op   │   sec/op      vs base           │
          // → Search-10  8.146µ ± 3%  1.003µ ± 2%  -87.69% (p=0.000 n=10)
          

          Ein einzelner Benchmark-Lauf ist rauschbehaftet (Thermal Throttling, Hintergrundprozesse, Scheduler); erst benchstat mit Konfidenzintervall und p-Wert macht aus zwei Messreihen eine Aussage. Ohne diese Baseline wird kein Fix committet.

          Schritt 2: Verstehen — das CPU-Profil führte zum wahren Engpass

          Das pprof-Flamegraph aus Lektion 96 zeigte für die Suche: 80 % der Zeit in bookstore.KategorieMatch — und nicht, wie vermutet, im JSON-Rendering. Der Code dahinter: Für jeden Artikel wird linear über alle 10.000 Kategorien iteriert — O(n·m). Schritt 3: Fixen — die Kategorien gehören in ein Set:

          // internal/search/match.go — der bewiesene Engpass und sein Fix
          package search
          
          import "fmt"
          
          // KategorieMatchAlt: für jeden Artikel lineare Suche über alle Kategorien
          func KategorieMatchAlt(artikel, kategorien []string) int {
          	n := 0
          	for _, a := range artikel {
          		for _, k := range kategorien {
          			if a == k {
          				n++
          				break
          			}
          		}
          	}
          	return n
          }
          
          // KategorieMatchSchnell: Kategorien einmal in ein Set — O(n+m)
          func KategorieMatchSchnell(artikel, kategorien []string) int {
          	set := make(map[string]struct{}, len(kategorien))
          	for _, k := range kategorien {
          		set[k] = struct{}{}
          	}
          	n := 0
          	for _, a := range artikel {
          		if _, ok := set[a]; ok {
          			n++
          		}
          	}
          	return n
          }
          
          func main() {
          	artikel := []string{"Der Prozess", "Siddhartha", "Unknown"}
          	kat := []string{"Siddhartha", "Der Prozess"}
          	fmt.Println(KategorieMatchAlt(artikel, kat), KategorieMatchSchnell(artikel, kat))
          	// → 2 2
          }
          

          Beachte die Reihenfolge: Erst der algorithmische Fix (O(n·m) → O(n+m), im benchstat oben −87,7 %), dann — falls immer noch nötig — die Mikro-Optimierungen aus Lektion 99. Umgekehrt wäre Mikro-Politur am falschen Berg. Schritt 4: Wiederholen — der nächste benchstat-Lauf belegt den Gewinn, das Allokations-Budget aus Lektion 99 sichert ihn dauerhaft, und erst dann geht es in die nächste Runde — oder die Messung sagt: gut genug, aufhören.

          Wann aufhören? Budgets, nicht Perfektion

          Performance-Arbeit endet nie „fertig", sondern an definierten Zielen: p95 unter 100 ms, null Allokationen pro Anfrage im Rendering-Pfad, GC-Pause unter 500 Mikrosekunden. Solche Budgets gehören als Tests (testing.AllocsPerRun, testing.B) in die CI — dann alarmiert der Build, wenn ein Refactor sie bricht, statt dass es der Black Friday tut. Wie man Latenz- und Lastziele für ganze Systeme ableitet (Caching, Read Replicas, Asynchronisierung), ist Gegenstand der Architektur-Reihe — die Grundlagen dazu in Modul 7: Skalierbarkeit: Performance ist die Basis, auf der jede Skalierung steht.

          Modul- und Kursabschluss: 100 Lektionen Go

          Damit endet sowohl Modul 20 als auch der Go-Kurs insgesamt — 100 Lektionen von go mod init bis zum GC-Tuning. Der Bogen: Sprache und Typsystem (Module 1–6), Nebenläufigkeit und Fehlerbehandlung (7–8), Testing und HTTP (9–10), Architektur und Frameworks (11–15), verteilte Systeme mit gRPC, Cloud-Native und Security (16–18), Daten-Pipelines (19) — und jetzt Performance als Querschnittsdisziplin. Der Optimierungs-Workflow ist dabei die Klammer: Messen, verstehen, fixen, wiederholen — für Code genauso wie für Karrieren.

          Wochen-Check: Beherrschst du folgende Punkte?

          1. Kannst du für einen laufenden Service CPU-, Heap-, Goroutine- und Mutex-Profile aufnehmen und den Engpass benennen?
          2. Sagt dir go build -gcflags="-m", warum eine Variable auf dem Heap landet — inklusive der 64-KB-Regel?
          3. Kannst du GOGC und GOMEMLIMIT begründet setzen und den Live-Heap per runtime/metrics messen?
          4. Kennst du die drei Zero-Alloc-Muster und ihre Grenzen (sync.Pool ist kein Cache)?
          5. Belegst du jede Optimierung mit benchstat — und weißt du, wann Aufhören das richtige Ergebnis ist?

          ⚠ Häufiger Fehler: Ohne Baseline und Vergleichsmessung „schneller" zu behaupten. Wer nach Gefühl optimiert, commitet manchmal Code, der langsamer ist, und merkt es erst am nächsten Black Friday — denn einzelne Benchmark-Läufe rauschen um zweistellige Prozente. Und die umgekehrte Falle ist genauso real: Mikro-Optimierungen an Cold Paths (Startcode, einmalige Initialisierung) sind reine Verschwendung von Lebenszeit. Ohne benchstat-Vergleich und identifizierten Engpass aus dem Profil ist jede Optimierung nur eine Hypothese.

          ✅ Wichtige Erkenntnisse

          Haken setzen, um deinen Lernfortschritt zu markieren:

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