Sebuah perlumbaan data (data race) berlaku apabila dua atau lebih goroutine mengakses memori yang sama secara serentak, sekurang-kurangnya satu akses ialah tulisan, dan tiada penyegerakan antara mereka. Hasilnya ialah tingkah laku tak tertakrif — data rosak, kemalangan, atau keputusan salah yang muncul secara berselang-seli. Go menyediakan pengesan race terbina dalam untuk mencarinya.
// ❌ 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++ ialah baca-ubah-suai-tulis (tiga langkah). Apabila goroutine berselang-seli, kemas kini menulis-ganti antara satu sama lain, jadi kiraan akhir tidak boleh diramal. Hasilnya berbeza antara larian — sifat licik perlumbaan.
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: ...
==================
Pengesan race mengukur akses memori pada masa jalan dan melaporkan dengan tepat di mana perlumbaan berlaku (akses yang bercanggah serta goroutine/barisnya). Ia salah satu alat Go yang paling berharga — jalankan ujian anda dengan -race secara berkala (terutamanya dalam CI) untuk menangkap perlumbaan sebelum pengeluaran.
// 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
Pembetulannya ialah alat penyegerakan: mutex untuk mensirikan akses, operasi atomic untuk pembilang ringkas, atau channel untuk mengelakkan perkongsian memori sama sekali.
✗ 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
Perlumbaan data adalah antara pepijat yang paling berbahaya dan paling sukar dinyahpepijat dalam Go serentak — dan reka bentuk Go yang berat dengan keserentakan menjadikannya risiko sebenar.
Ia licik kerana ia tidak deterministik: kod dengan perlumbaan mungkin lulus semua ujian dan berfungsi baik di bawah beban ringan, kemudian gagal secara berselang-seli dalam pengeluaran di bawah beban serentak, menghasilkan data rosak, keputusan salah, atau kemalangan yang hampir mustahil dihasilkan semula.
Memahami takrif tepat (akses serentak kepada memori dikongsi dengan sekurang-kurangnya satu tulisan dan tiada penyegerakan), menyedari bahawa kod yang kelihatan tidak berdosa seperti counter++ pun mengalami perlumbaan, dan mengetahui pembetulannya (mutex, atomic, channel) adalah penting untuk menulis Go serentak yang betul.
Yang kritikal, pengesan race terbina dalam Go (-race) ialah alat yang tidak boleh ditolak — menjalankan ujian dengannya (idealnya dalam CI) menangkap perlumbaan yang sebaliknya tidak kelihatan.
Menguasai pengesanan dan pencegahan perlumbaan ialah kemahiran asas untuk Go serentak gred pengeluaran dan salah satu topik lanjutan yang paling penting dalam bahasa ini, kerana ketepatan keserentakan ialah tempat program Go paling kerap gagal.