Data race tapahtuu, kun kaksi tai useampia goroutineja käyttää samaa muistiosoitetta samanaikaisesti, vähintään yksi pääsy on kirjoitus, ja niiden välillä ei ole synkronointia. Tuloksena on määrittelemätön käyttäytyminen — korruptoitunut data, kaatumisia tai väärät tulokset, jotka ilmestyvät satunnaisesti. Go tarjoaa sisäänrakennetun race detectorin niiden etsimiseen.
// ❌ 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++ on read-modify-write (kolme vaihetta). Kun goroutiinit lomittuvat, päivitykset ylikirjoittavat toisensa, joten lopullinen luku on ennustamaton. Tulos vaihtelee ajojen välillä — racejen petollisuus.
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: ...
==================
Race detector instrumentoi muistin käyttöä ajon aikaisesti ja raportoi tarkalleen, missä race tapahtuu (ristiriitaiset pääsyt ja niiden goroutiinit/rivit). Se on yksi Gon arvokkaimpia työkaluja — suorita testisi säännöllisesti -race lipulla (erityisesti CI:ssä) racejen kiinni saamiseksi ennen tuotantoa.
// 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
Korjaukset ovat synkronointivälineitä: mutex pääsyn sarjoittamiseen, atomic operaatiot yksinkertaisille laskureille tai channels muistin jakamisen välttämiseksi kokonaan.
✗ 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
Data racet ovat samanaikaisen Gon vaarallisimmista ja vaikeimmin debugattavista virheistä — ja Gon samanaikaisuuskeskeinen suunnittelu tekee niistä todellisen riskin.
Ne ovat petolliset, koska ne ovat epädeterministisiä: koodi racella voi läpäistä kaikki testit ja toimia hyvin kevyen kuormituksen alla, mutta epäonnistua satunnaisesti tuotannossa korkeammalla samanaikaiskuormalla, tuottaen korruptoitunutta dataa, väärät tulokset tai kaatumisia, joita on lähes mahdotonta uudelleen tuottaa.
Tarkan määritelmän ymmärtäminen (samanaikainen pääsy jaettuun muistiin vähintään yhden kirjoituksen kanssa ja ilman synkronointia), tunnistaminen, että jopa viattomalta näyttävä koodi kuten counter++ aiheuttaa racen, ja tietäminen korjauksista (mutex, atomic, channels) on olennaista oikean samanaikaisen Gon kirjoittamiseen.
Kriittisesti, Gon sisäänrakennettu race detector (-race) on välttämätön väline — testien ajaminen sen kanssa (ihanteellisesti CI:ssä) kiinni ottaa racet, jotka ovat muutoin näkymättömiä.
Race detektorin hallitseminen ja niiden estäminen on perusosaamista tuotantotasoisen samanaikaisen Gon kirjoittamiselle ja yksi kielen tärkeimmistä edistyneistä aiheista, koska samanaikaiskorrektius on tarkalleen se paikka, jossa Go-ohjelmat useimmiten epäonnistuvat.