Co to jest race condition i jak ją wykryć?

Question

Accepted Answer

**Race condition** (wyścig o dane) występuje, gdy dwie lub więcej goroutin uzyskuje dostęp do **tej samej pamięci** jednocześnie, co najmniej jeden dostęp jest **zapisem**, i **brak synchronizacji** między nimi. Rezultatem jest niezdefiniowane zachowanie — uszkodzone dane, awarie lub nieprawidłowe wyniki pojawiające się sporadycznie. Go udostępnia wbudowany **detektor race'ów** do ich wyszukania.

## Co wygląda jak race condition

```go
// ❌ 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++` to operacja read-modify-write (trzy kroki). Gdy goroutiny się przeplatają, aktualizacje nadpisują się nawzajem, więc ostateczna wartość licznika jest nieprzewidywalna. Wynik *różni się między uruchomieniami* — zły znak wyścigów o dane.

## Detektor race'ów — supermoce Go

```bash
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
```

```text
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'ów** instrumentuje dostępy do pamięci w czasie wykonania i raportuje dokładnie gdzie dochodzi do wyścigu (konfliktowe dostępy i ich goroutiny/linie). To jedno z najcenniejszych narzędzi Go — regularnie uruchamiaj testy z `-race` (szczególnie w CI) aby złapać race'y zanim trafią do produkcji.

## Naprawianie race conditions

```go
// 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
```

Naprawy to narzędzia synchronizacyjne: **mutex** aby serializować dostęp, operacje **atomic** dla prostych liczników, lub **channels** aby całkowicie uniknąć dzielenia pamięci.

## Dlaczego wyścigi o dane są niebezpieczne

```text
✗ 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
```

## Dlaczego to ważne

Wyścigi o dane to jedne z najbardziej niebezpiecznych i najtrudniejszych do debugowania błędów w konkurencyjnym Go — a projekt Go zorientowany na współbieżność sprawia, że stanowią realne zagrożenie.

Są zdradliwe, ponieważ są **niedeterministyczne**: kod z race'iem może przejść wszystkie testy i pracować dobrze przy lekkiej obciążeniu, a następnie zawodzić sporadycznie w produkcji przy współbieżnym obciążeniu, produkując uszkodzone dane, złe wyniki lub awarie, które są prawie niemożliwe do reprodukcji.

Zrozumienie precyzyjnej definicji (współbieżny dostęp do pamięci współdzielonej z co najmniej jednym zapisem i brakiem synchronizacji), rozpoznawanie że nawet pozornie nieszkodliwy kod jak `counter++` ma race'y, i znajomość napraw (mutex, atomic, channels) jest kluczowa do pisania poprawnego konkurencyjnego Go.

Krytycznie ważne, że wbudowany **detektor race'ów** Go (`-race`) to niezastąpione narzędzie — uruchamianie testów z nim (najlepiej w CI) łapie race'y, które są inaczej niewidoczne.

Opanowanie detektowania race'ów i ich zapobiegania to fundamentalna umiejętność dla produkcyjnego konkurencyjnego Go i jeden z najważniejszych zaawansowanych tematów w języku, ponieważ poprawność współbieżności to dokładnie to, gdzie programy Go najczęściej zawodzą.