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.
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)stattlocalhost:6060schreibt, stellt Stacktraces, Quellcode-Pfade und im Heap-Dump sogar Kundendaten ins Netz. Immer anlocalhostoder 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:
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
- Implizite Allokationen (make, Slice-Literale) mit konstanter Größe über 64 KB entkommen auf den Heap —
maxImplicitStackVarSizeim Compilercmd/compile. 2. Nicht-konstante Größen wiemake([]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, wennpden 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:
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.gcBgMarkWorkerund 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:
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 vorherigesbuf.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:
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?
- Kannst du für einen laufenden Service CPU-, Heap-, Goroutine- und Mutex-Profile aufnehmen und den Engpass benennen?
- Sagt dir
go build -gcflags="-m", warum eine Variable auf dem Heap landet — inklusive der 64-KB-Regel? - Kannst du GOGC und GOMEMLIMIT begründet setzen und den Live-Heap per
runtime/metricsmessen? - Kennst du die drei Zero-Alloc-Muster und ihre Grenzen (
sync.Poolist kein Cache)? - 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: