Datová race se vyskytuje, když dva nebo více goroutin přistupuje ke stejné paměti současně, alespoň jeden přístup je zapis a mezi nimi není synchronizace. Výsledek je nedefinované chování — poškozená data, pády nebo chybné výsledky, které se objevují přerušovaně. Go poskytuje vestavěný detektor race k jejich nalezení.
// ❌ DATA RACE — multiple goroutines write the same variable without synchronization
func main() {
counter := 0
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
counter++ // RACE: read-modify-write, multiple goroutines at once
}()
}
wg.Wait()
fmt.Println(counter) // often NOT 1000 — updates are lost due to the race
}
counter++ je čtení-modifikace-zapis (tři kroky). Když se goroutiny prokládají, aktualizace se navzájem přepisují, takže finální počet je nepředvídatelný. Výsledek se liší mezi jednotlivými spuštěními — zákeřná povaha race.
go run -race main.go # run with race detection enabled
go test -race ./... # run tests with the race detector (best practice in CI)
go build -race # build a race-detecting binary
The race detector reports each race it observes:
==================
WARNING: DATA RACE
Write at 0x... by goroutine 7: main.main.func1() main.go:12
Previous read at 0x... by goroutine 6: ...
==================
Detektor race instrumentuje přístupy do paměti za běhu a přesně hlásí, kde se race stane (konfliktní přístupy a jejich goroutiny/řádky). Je to jeden z nejcennějších nástrojů Go — spouštějte své testy s -race pravidelně (zejména v CI), abyste zachytili race před produktivním nasazením.
// Fix 1: protect with a mutex
var mu sync.Mutex
mu.Lock(); counter++; mu.Unlock()
// Fix 2: use atomic operations (lock-free, for simple values)
import "sync/atomic"
var counter int64
atomic.AddInt64(&counter, 1) // atomic — no race
// Fix 3: don't share — use channels to pass ownership
results := make(chan int)
// each goroutine sends its result; one goroutine aggregates
Opravy jsou synchronizační nástroje: mutex pro serializaci přístupu, atomic operace pro jednoduché čítače nebo kanály aby se zabránilo sdílení paměti.
✗ NON-DETERMINISTIC — may work in testing, fail in production (timing-dependent)
✗ Hard to reproduce — depends on goroutine scheduling, load, hardware
✗ UNDEFINED behavior — not just wrong values; can corrupt data or crash
✗ Often invisible without the race detector — no error, just subtly wrong results
Dataové race patří mezi nejnebezpečnější a nejtěžší chyby k ladění v souběžném Go — a design Go se silným zaměřením na souběžnost je činí skutečným rizikem.
Jsou zákeřné, protože jsou nedeterministické: kód s race může projít všemi testy a pracovat správně při slabém zatížení, ale pak selže přerušovaně v produkci pod souběžným zatížením, čímž způsobí poškozená data, chybné výsledky nebo pády, které jsou téměř nemožné reprodukovat.
Porozumění přesné definici (souběžný přístup ke sdílené paměti s alespoň jedním zápisem bez synchronizace), rozpoznávání toho, že i zdánlivě nevinný kód jako counter++ race způsobuje, a znalost oprav (mutex, atomic, kanály) je nezbytné pro psaní správného souběžného Go.
Kriticky je Go vestavěný detektor race (-race) nepostradatelný nástroj — spouštění testů s ním (ideálně v CI) zachytí race, které by jinak byly neviditelné.
Ovládnutí detekce a prevence race je základní dovedností pro produční souběžné Go a jedním z nejdůležitějších pokročilých témat v jazyce, protože správnost souběžnosti je přesně tam, kde Go programy nejčastěji selhávají.