Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Nebenläufigkeit – urlcheck

Ziel: Ein URL-Prüfer mit Worker-Pool, Rate-Limit und sauberem Abbruch – und du siehst mit dem Race-Detector, warum geteilter Zustand gefährlich ist · Dauer: ca. 150 min · Voraussetzung: Tag 7

Briefing

  • Goroutine = go f() bzw. wg.Go(f); sync.WaitGroup wartet auf alle.
  • Channels verteilen Arbeit: ein jobs-Channel, N Worker, close beendet sie.
  • select wartet auf mehrere Ereignisse – Rate-Limit-Tick oder Abbruch per ctx.Done().
  • go test -race findet Data Races, bevor sie in Produktion falsche Zahlen liefern.
  • Jeder Worker schreibt nur seinen eigenen Slice-Index – so braucht das Ergebnis kein Lock.
urls --> jobs (chan int) --> Worker 1 --\
                         --> Worker 2 ---+--> results[i]   (Index = Reihenfolge)
                         --> Worker N --/
             tick (Ticker) / ctx.Done()  bremsen bzw. stoppen alle

Drill 1: Modul und URL-Liste

mkdir -p ~/go-lab/tag08-urlcheck && cd ~/go-lab/tag08-urlcheck
go mod init example.com/urlcheck
mkdir -p cmd/urlcheck internal/check demo/race

Erwartet:

go: creating new go.mod: module example.com/urlcheck
cat > urls.txt <<'EOF'
# Lab-Liste: öffentliche Seiten plus absichtliche Fehler
https://go.dev
https://kubernetes.io
https://openbao.org
https://example.com
https://pkg.go.dev/net/http
https://github.com/golang/go
https://www.cncf.io
https://httpbin.org/status/503
https://github.com/nobody-xyz/nope-123
https://nicht-vorhanden.invalid
EOF

Die letzten drei Einträge sind absichtlich kaputt: Serverfehler, 404 und ein Name unter der reservierten TLD .invalid, die nie auflöst.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eine URL prüfen

Erst die Einheit, die parallel laufen soll – ohne jede Nebenläufigkeit. Result enthält alles, auch den Fehler als String, damit es sich als JSON ausgeben lässt.

cat > internal/check/check.go <<'EOF'
// Package check prüft URLs nebenläufig mit Worker-Pool und Rate-Limit.
package check

import (
    "context"
    "io"
    "net/http"
    "time"
)

// Result ist das Ergebnis für eine URL.
type Result struct {
    URL      string        `json:"url"`
    Status   int           `json:"status"`
    Duration time.Duration `json:"duration_ns"`
    Err      string        `json:"error,omitempty"`
}

// OK: Antwort erhalten und Status < 400.
func (r Result) OK() bool { return r.Err == "" && r.Status < 400 }

// Checker hält die Einstellungen; der Nullwert ist nicht nutzbar.
type Checker struct {
    HTTP    *http.Client
    Workers int     // gleichzeitige Anfragen
    RPS     float64 // Anfragen pro Sekunde gesamt, 0 = unbegrenzt
}

// One prüft genau eine URL.
func (c *Checker) One(ctx context.Context, url string) Result {
    start := time.Now()
    res := Result{URL: url}
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        res.Err = err.Error()
        return res
    }
    req.Header.Set("User-Agent", "urlcheck-lab")
    resp, err := c.HTTP.Do(req)
    if err != nil {
        res.Err = err.Error()
        res.Duration = time.Since(start)
        return res
    }
    defer resp.Body.Close()
    // Body (begrenzt) lesen, damit die Verbindung wiederverwendet werden kann.
    _, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 1<<20))
    res.Status = resp.StatusCode
    res.Duration = time.Since(start)
    return res
}
EOF

Warum den Body lesen? Der HTTP-Client legt eine Verbindung erst zurück in den Pool, wenn der Body bis zum Ende gelesen und geschlossen ist. LimitReader verhindert, dass eine 2-GB-Datei durchgezogen wird.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Goroutines und der Race-Detector

Bevor du parallel prüfst, ein Experiment: 1000 Goroutines zählen denselben Zähler hoch. wg.Go (seit Go 1.25) startet eine Goroutine und meldet sie bei der WaitGroup an.

cat > demo/race/main.go <<'EOF'
// Absichtlich kaputt: 1000 Goroutines erhöhen denselben Zähler.
package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    ok := 0
    for range 1000 {
        wg.Go(func() { ok++ }) // Lesen, +1, Schreiben – nicht atomar
    }
    wg.Wait()
    fmt.Println("ok =", ok)
}
EOF
for i in 1 2 3; do go run ./demo/race; done
go run -race ./demo/race 2>&1 | grep -E 'WARNING|main.go|ok =|Found'

Erwartet (gekürzt, Zahlen variieren bei jedem Lauf):

ok = 985
ok = 965
ok = 976
WARNING: DATA RACE
      /Users/.../tag08-urlcheck/demo/race/main.go:13 +0x2c
      /Users/.../tag08-urlcheck/demo/race/main.go:13 +0x3c
WARNING: DATA RACE
      /Users/.../tag08-urlcheck/demo/race/main.go:13 +0x3c
      /Users/.../tag08-urlcheck/demo/race/main.go:13 +0x3c
ok = 857
Found 2 data race(s)

Warum? ok++ sind drei Schritte; zwei Goroutines lesen denselben Wert und eine Erhöhung geht verloren. Der Race-Detector zeigt Datei und Zeile beider Zugriffe. Die Reparatur macht das Erhöhen unteilbar:

cat > demo/race/main.go <<'EOF'
// Repariert: atomic.Int64 macht das Erhöhen unteilbar.
package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var wg sync.WaitGroup
    var ok atomic.Int64
    for range 1000 {
        wg.Go(func() { ok.Add(1) })
    }
    wg.Wait()
    fmt.Println("ok =", ok.Load())
}
EOF
go run -race ./demo/race

Erwartet:

ok = 1000

Tipp: Für einen Zähler reicht atomic; sobald mehrere Felder zusammen konsistent sein müssen, nimm sync.Mutex – wie im Test in Drill 6.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Worker-Pool mit Channels

Unbegrenzt viele Goroutines (eine pro URL) würden bei 10 000 URLs 10 000 Verbindungen gleichzeitig öffnen. Ein Pool begrenzt das: N Worker lesen Indizes aus einem Channel.

cat > internal/check/pool.go <<'EOF'
package check

import (
    "context"
    "sync"
    "time"
)

// Run prüft alle URLs mit c.Workers Goroutines. Ergebnisse in Eingabe-Reihenfolge.
func (c *Checker) Run(ctx context.Context, urls []string) []Result {
    results := make([]Result, len(urls))
    jobs := make(chan int) // Index in urls

    // Rate-Limit: jeder Worker holt sich vor der Anfrage einen Tick.
    var tick <-chan time.Time
    if c.RPS > 0 {
        t := time.NewTicker(time.Duration(float64(time.Second) / c.RPS))
        defer t.Stop()
        tick = t.C
    }

    var wg sync.WaitGroup
    for range max(c.Workers, 1) {
        wg.Go(func() {
            for i := range jobs { // endet, wenn jobs geschlossen ist
                if tick != nil {
                    select {
                    case <-tick:
                    case <-ctx.Done():
                        results[i] = Result{URL: urls[i], Err: ctx.Err().Error()}
                        continue
                    }
                }
                results[i] = c.One(ctx, urls[i]) // eigener Index: kein Lock nötig
            }
        })
    }

    for i := range urls {
        jobs <- i
    }
    close(jobs)
    wg.Wait()
    return results
}
EOF

Warum ist results[i] = … ohne Lock sicher? Jeder Index wird von genau einer Goroutine geschrieben, und wg.Wait() garantiert, dass alle Schreibvorgänge vor dem return sichtbar sind. Ein gemeinsames append wäre dagegen ein Data Race. Ein nil-Channel (tick ohne Rate-Limit) blockiert im select für immer – deshalb die Prüfung davor.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Das CLI

URLs kommen aus Dateien oder stdin; io.MultiReader hängt mehrere Dateien hintereinander, als wären sie eine.

cat > cmd/urlcheck/main.go <<'EOF'
// urlcheck prüft URLs parallel: urlcheck [-c 8] [-rps 0] [-json] [DATEI...]
package main

import (
    "bufio"
    "context"
    "encoding/json"
    "flag"
    "fmt"
    "io"
    "net/http"
    "os"
    "os/signal"
    "strings"
    "time"

    "example.com/urlcheck/internal/check"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], os.Stdin, os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer,
) int {
    fl := flag.NewFlagSet("urlcheck", flag.ContinueOnError)
    fl.SetOutput(stderr)
    workers := fl.Int("c", 8, "gleichzeitige Anfragen")
    rps := fl.Float64("rps", 0, "max. Anfragen pro Sekunde (0 = unbegrenzt)")
    timeout := fl.Duration("timeout", 10*time.Second, "Timeout pro URL")
    asJSON := fl.Bool("json", false, "JSON-Ausgabe")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    urls, err := readURLs(fl.Args(), stdin)
    if err != nil {
        fmt.Fprintln(stderr, "urlcheck:", err)
        return 2
    }

    c := &check.Checker{
        HTTP:    &http.Client{Timeout: *timeout},
        Workers: *workers,
        RPS:     *rps,
    }
    start := time.Now()
    results := c.Run(ctx, urls)

    failed := 0
    for _, r := range results {
        if !r.OK() {
            failed++
        }
    }
    if *asJSON {
        _ = json.NewEncoder(stdout).Encode(results)
    } else {
        for _, r := range results {
            mark, status := "✔", fmt.Sprint(r.Status)
            if !r.OK() {
                mark = "✘"
            }
            if r.Err != "" {
                status = "ERR"
            }
            line := fmt.Sprintf("%s %-3s %5dms %s", mark, status,
                r.Duration.Milliseconds(), r.URL)
            if r.Err != "" {
                line += "  " + r.Err
            }
            fmt.Fprintln(stdout, line)
        }
        fmt.Fprintf(stdout, "%d URLs, %d fehlerhaft, %d Worker, %v\n", len(urls),
            failed, *workers, time.Since(start).Round(time.Millisecond))
    }
    if failed > 0 {
        return 1
    }
    return 0
}

// readURLs liest eine URL pro Zeile aus Dateien oder stdin; # = Kommentar.
func readURLs(files []string, stdin io.Reader) ([]string, error) {
    readers := []io.Reader{stdin}
    if len(files) > 0 {
        readers = nil
        for _, name := range files {
            f, err := os.Open(name)
            if err != nil {
                return nil, err
            }
            defer f.Close()
            readers = append(readers, f)
        }
    }
    var urls []string
    sc := bufio.NewScanner(io.MultiReader(readers...))
    for sc.Scan() {
        line := strings.TrimSpace(sc.Text())
        if line != "" && !strings.HasPrefix(line, "#") {
            urls = append(urls, line)
        }
    }
    return urls, sc.Err()
}
EOF
cp ../tag07-ghrel/.golangci.yml .
go vet ./... && go build -o urlcheck ./cmd/urlcheck
./urlcheck -c 1 urls.txt | tail -1
./urlcheck urls.txt; echo "Exit: $?"
./urlcheck -c 10 -rps 2 urls.txt | tail -1

Erwartet (gekürzt, Zeiten hängen von deinem Netz ab):

10 URLs, 3 fehlerhaft, 1 Worker, 2.797s
✔ 200   214ms https://go.dev
✔ 200    82ms https://kubernetes.io
✔ 200    99ms https://openbao.org
✔ 200    63ms https://example.com
✔ 200   578ms https://pkg.go.dev/net/http
✔ 200   163ms https://github.com/golang/go
✔ 200   117ms https://www.cncf.io
✘ 503   487ms https://httpbin.org/status/503
✘ 404    78ms https://github.com/nobody-xyz/nope-123
✘ ERR     1ms https://nicht-vorhanden.invalid  Get "https://nicht-vorhanden.invalid…
10 URLs, 3 fehlerhaft, 8 Worker, 578ms
Exit: 1
10 URLs, 3 fehlerhaft, 10 Worker, 5.123s

Warum? Seriell addieren sich die Zeiten (2,8 s), parallel dauert der Lauf so lange wie die langsamste URL (578 ms). Mit -rps 2 bremst der Ticker auf 2 Anfragen pro Sekunde – 10 Worker helfen dann nichts, 10 URLs brauchen 5 s. Die Reihenfolge der Ausgabe bleibt trotz Parallelität die der Datei.

Achtung: Prüfe fremde Server nur mit Augenmaß. -rps ist kein Extra, sondern Höflichkeit – und schützt dich vor dem Rate-Limit des Ziels.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Nebenläufigkeit testen

Parallelität prüfst du nicht mit Bauchgefühl, sondern messbar: Ein langsamer Testserver zählt, wie viele Anfragen gleichzeitig bei ihm sind. Hier schützt ein sync.Mutex zwei Felder, die zusammengehören.

cat > internal/check/pool_test.go <<'EOF'
package check

import (
    "context"
    "net/http"
    "net/http/httptest"
    "sync"
    "testing"
    "time"
)

// slowServer antwortet nach delay; peak() liefert die maximale Parallelität.
func slowServer(t *testing.T, delay time.Duration) (*httptest.Server, func() int) {
    t.Helper()
    var mu sync.Mutex
    cur, peak := 0, 0
    h := func(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        cur++
        peak = max(peak, cur)
        mu.Unlock()
        time.Sleep(delay)
        mu.Lock()
        cur--
        mu.Unlock()
        if r.URL.Path == "/fail" {
            w.WriteHeader(http.StatusInternalServerError)
        }
    }
    srv := httptest.NewServer(http.HandlerFunc(h))
    t.Cleanup(srv.Close)
    return srv, func() int { mu.Lock(); defer mu.Unlock(); return peak }
}

func urls(base string, n int) []string {
    out := make([]string, n)
    for i := range out {
        out[i] = base + "/ok"
    }
    return out
}

func TestRunReihenfolge(t *testing.T) {
    srv, _ := slowServer(t, 0)
    c := &Checker{HTTP: srv.Client(), Workers: 3}
    in := []string{srv.URL + "/ok", srv.URL + "/fail", "http://127.0.0.1:9/zu"}
    res := c.Run(context.Background(), in)
    for i, want := range []bool{true, false, false} {
        if res[i].URL != in[i] || res[i].OK() != want {
            t.Errorf("res[%d] = %+v, want OK=%v", i, res[i], want)
        }
    }
}

func TestRunWorkerLimit(t *testing.T) {
    srv, peak := slowServer(t, 50*time.Millisecond)
    c := &Checker{HTTP: srv.Client(), Workers: 5}
    start := time.Now()
    c.Run(context.Background(), urls(srv.URL, 20))
    if p := peak(); p != 5 {
        t.Errorf("max. parallel = %d, want 5", p)
    }
    if d := time.Since(start); d > 500*time.Millisecond { // seriell: 1 s
        t.Errorf("Dauer %v – läuft das parallel?", d)
    }
}

func TestRunRateLimit(t *testing.T) {
    srv, _ := slowServer(t, 0)
    c := &Checker{HTTP: srv.Client(), Workers: 10, RPS: 50} // alle 20 ms
    start := time.Now()
    c.Run(context.Background(), urls(srv.URL, 10))
    if d := time.Since(start); d < 180*time.Millisecond {
        t.Errorf("10 Anfragen in %v – Rate-Limit greift nicht", d)
    }
}

func TestRunAbbruch(t *testing.T) {
    srv, _ := slowServer(t, time.Second)
    c := &Checker{HTTP: srv.Client(), Workers: 2, RPS: 1}
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
    start := time.Now()
    for _, r := range c.Run(ctx, urls(srv.URL, 6)) {
        if r.OK() {
            t.Errorf("%s OK trotz Abbruch", r.URL)
        }
    }
    if d := time.Since(start); d > 500*time.Millisecond {
        t.Errorf("Abbruch dauerte %v", d)
    }
}
EOF

Das CLI selbst bekommt zwei kleine Tests – stdin ist ein strings.Reader, das Ziel ein httptest-Server, der immer 404 liefert:

cat > cmd/urlcheck/main_test.go <<'EOF'
package main

import (
    "bytes"
    "context"
    "net/http"
    "net/http/httptest"
    "slices"
    "strings"
    "testing"
)

func TestReadURLs(t *testing.T) {
    in := "# Kommentar\nhttps://a.example\n\n  https://b.example  \n"
    got, err := readURLs(nil, strings.NewReader(in))
    want := []string{"https://a.example", "https://b.example"}
    if err != nil || !slices.Equal(got, want) {
        t.Errorf("readURLs = %v, %v; want %v", got, err, want)
    }
}

func TestRunExitCode(t *testing.T) {
    srv := httptest.NewServer(http.NotFoundHandler())
    defer srv.Close()
    var out bytes.Buffer
    code := run(context.Background(), []string{"-json"},
        strings.NewReader(srv.URL+"\n"), &out, &out)
    if code != 1 || !strings.Contains(out.String(), `"status":404`) {
        t.Errorf("Exit %d, Ausgabe %s", code, out.String())
    }
}
EOF
go test -race -count=1 -v ./... 2>&1 | grep -E '^(---|ok|\?)'

Erwartet:

--- PASS: TestReadURLs (0.00s)
--- PASS: TestRunExitCode (0.00s)
ok      example.com/urlcheck/cmd/urlcheck   1.310s
?       example.com/urlcheck/demo/race  [no test files]
--- PASS: TestRunReihenfolge (0.00s)
--- PASS: TestRunWorkerLimit (0.21s)
--- PASS: TestRunRateLimit (0.20s)
--- PASS: TestRunAbbruch (0.10s)
ok      example.com/urlcheck/internal/check 1.685s

Warum 0,21 s im Worker-Test? 20 Anfragen à 50 ms mit 5 Workern sind 4 Runden – seriell wären es 1 s. Lass -race bei nebenläufigem Code immer mitlaufen; er kostet Zeit, findet aber Fehler, die sonst nur unter Last auftreten.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Das Tool ist fertig

gofmt -l . && go vet ./... && ~/go-lab/bin/lint run ./...
./urlcheck -json urls.txt \
  | jq -r '.[] | select(.error != null or .status >= 400) | .url'
./urlcheck -rps 1 urls.txt   # nach ca. 2 s Strg+C drücken

Erwartet (gekürzt):

0 issues.
https://httpbin.org/status/503
https://github.com/nobody-xyz/nope-123
https://nicht-vorhanden.invalid
✘ ERR     0ms https://go.dev  context canceled
✘ ERR     0ms https://kubernetes.io  context canceled
✔ 200    56ms https://openbao.org
✔ 200    58ms https://example.com
…
10 URLs, 8 fehlerhaft, 8 Worker, 2.501s

Strg+C beendet den Signal-Context; wartende Worker verlassen ihr select sofort, die Zusammenfassung erscheint trotzdem. Welche URLs vor dem Abbruch drankamen, ist zufällig – die Worker konkurrieren um jeden Tick. Garantiert ist nur die Reihenfolge der Ausgabe.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/go-lab/tag08-urlcheck
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
go vet ./... && go test -race -count=1 ./... >/dev/null && ok "Tests mit -race" \
  || nok "Tests"
[ "$(go run ./demo/race)" = "ok = 1000" ] && ok "Zähler repariert" || nok "Race-Demo"
./urlcheck urls.txt >/dev/null; [ $? -eq 1 ] && ok "Exit 1 bei Fehlern" || nok "Exit"
s=$(date +%s); ./urlcheck -c 10 -rps 4 urls.txt >/dev/null
[ $(( $(date +%s) - s )) -ge 2 ] && ok "Rate-Limit bremst" || nok "Rate-Limit"
echo https://go.dev | ./urlcheck | grep -q '1 URLs, 0 fehlerhaft' && ok "stdin" \
  || nok "stdin"

Erwartet:

✔ Tests mit -race
✔ Zähler repariert
✔ Exit 1 bei Fehlern
✔ Rate-Limit bremst
✔ stdin

Challenge

Schreibe RunGroup als Alternative zu Run: dieselbe Begrenzung auf c.Workers, aber mit errgroup.Group und SetLimit statt eigener Channels (Rate-Limit darf entfallen). Teste, dass nie mehr als 4 Anfragen gleichzeitig laufen.

Hinweis: g.Go blockiert, sobald das Limit erreicht ist; URL-Fehler gehören ins Result, nicht in den Rückgabewert der Goroutine – sonst bricht WithContext alle anderen ab.

Lösung

go get golang.org/x/[email protected]
cat > internal/check/group.go <<'EOF'
package check

import (
    "context"

    "golang.org/x/sync/errgroup"
)

// RunGroup macht dasselbe wie Run (ohne Rate-Limit) – mit errgroup statt Channels.
func (c *Checker) RunGroup(ctx context.Context, urls []string) []Result {
    results := make([]Result, len(urls))
    var g errgroup.Group
    g.SetLimit(max(c.Workers, 1)) // g.Go blockiert, wenn alle Plätze belegt sind
    for i, u := range urls {
        g.Go(func() error {
            results[i] = c.One(ctx, u)
            return nil // URL-Fehler stehen im Result, nicht im Gruppenfehler
        })
    }
    _ = g.Wait()
    return results
}
EOF
cat > internal/check/group_test.go <<'EOF'
package check

import (
    "context"
    "testing"
    "time"
)

func TestRunGroupWorkerLimit(t *testing.T) {
    srv, peak := slowServer(t, 20*time.Millisecond)
    c := &Checker{HTTP: srv.Client(), Workers: 4}
    res := c.RunGroup(context.Background(), urls(srv.URL, 12))
    if p := peak(); p != 4 || !res[11].OK() {
        t.Errorf("peak = %d, res[11] = %+v", p, res[11])
    }
}
EOF
go mod tidy
go test -race -count=1 -run RunGroup -v ./internal/check | grep -E '^(---|ok)'

Erwartet:

go: added golang.org/x/sync v0.24.0
--- PASS: TestRunGroupWorkerLimit (0.07s)
ok      example.com/urlcheck/internal/check 1.235s

Seit Go 1.22 hat jede Schleifeniteration eigene Variablen i und u – das früher nötige i, u := i, u vor g.Go entfällt. Welche Variante besser ist? errgroup ist kürzer; der eigene Pool erlaubt Rate-Limit und feinere Kontrolle.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Ausgehende Verbindungen begrenzen: http.Transport.MaxConnsPerHost zusätzlich zum Worker-Limit, sonst trifft ein großer Pool einen einzelnen Host mit voller Wucht.
  • Für verteilte Rate-Limits (mehrere Pods) reicht ein lokaler Ticker nicht; golang.org/x/time/rate pro Ziel plus zentrale Begrenzung am Egress-Gateway.
  • Synthetisches Monitoring gehört in Blackbox-Exporter oder einen eigenen Prober mit Prometheus-Metriken (Tag 9) – nicht in Cronjobs mit Mail-Ausgabe.
  • Goroutine-Lecks sind die häufigsten Speicherlecks in Go: Jede Goroutine braucht einen Weg zum Ende (Context, geschlossener Channel). goleak von Uber prüft das in Tests.
  • Interne URLs mit Firmen-CA: Trust-Store statt InsecureSkipVerify – Letzteres schaltet die Prüfung für alle Ziele ab.