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.WaitGroupwartet auf alle. - Channels verteilen Arbeit: ein
jobs-Channel, N Worker,closebeendet sie. selectwartet auf mehrere Ereignisse – Rate-Limit-Tick oder Abbruch perctx.Done().go test -racefindet 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/raceErwartet:
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
EOFDie 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
}
EOFWarum 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())
}
EOFgo run -race ./demo/raceErwartet:
ok = 1000
Tipp: Für einen Zähler reicht
atomic; sobald mehrere Felder zusammen konsistent sein müssen, nimmsync.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
}
EOFWarum 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()
}
EOFcp ../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 -1Erwartet (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ß.
-rpsist 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)
}
}
EOFDas 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())
}
}
EOFgo 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ückenErwartet (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.MaxConnsPerHostzusä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/ratepro 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).
goleakvon 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.