fatal error: concurrent map writes
Mai multe goroutine scriu în același map fără sincronizare. Map-urile din Go nu sunt sigure pentru acces concurent, iar runtime-ul oprește programul (nu se poate prinde cu recover). Protejează map-ul cu un sync.Mutex sau folosește sync.Map.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Un map obișnuit nu suportă scrieri simultane din mai multe goroutine. Runtime-ul Go detectează situația și oprește tot programul cu fatal error: concurrent map writes. Spre deosebire de o panică, o eroare fatală nu poate fi prinsă cu recover.
Variante ale aceluiași mesaj: fatal error: concurrent map read and map write (o goroutină citește în timp ce alta scrie) și fatal error: concurrent map iteration and map write (un range peste map în timp ce altă goroutină scrie).
Detecția e „cu noroc”: programul poate merge de zeci de ori și pica abia sub încărcare, în producție. Stiva de sub mesaj arată goroutina care scria (main.main.func1 înseamnă funcția anonimă din main). Pentru a găsi toate accesele nesincronizate, rulează programul sau testele cu -race (go run -race ., go test -race ./...).
De ce apare: cauzele frecvente
1Contor partajat între goroutine
vizite := map[string]int{}
for i := 0; i < 50; i++ {
go func() {
vizite["acasa"]++
}()
}var mu sync.Mutex
vizite := map[string]int{}
for i := 0; i < 50; i++ {
go func() {
mu.Lock()
vizite["acasa"]++
mu.Unlock()
}()
}Mutex-ul permite unei singure goroutine pe rând să modifice map-ul.
2Cache global accesat din handlere HTTP
var cache = map[string]string{}
func handler(w http.ResponseWriter, r *http.Request) {
cache[r.URL.Path] = "..."
}var (
mu sync.RWMutex
cache = map[string]string{}
)
func handler(w http.ResponseWriter, r *http.Request) {
mu.Lock()
cache[r.URL.Path] = "..."
mu.Unlock()
}Fiecare cerere HTTP rulează în goroutina ei, deci orice map global trebuie protejat. RWMutex permite cititori multipli simultan.
3Fiecare goroutină își ține rezultatul
go func(i int) {
rezultate[i] = calc(i) // map partajat
}(i)out := make(chan [2]int)
go func(i int) {
out <- [2]int{i, calc(i)}
}(i)
// main citește din out și scrie singur în mapAlternativa fără mutex: goroutinele trimit rezultatele pe un canal, iar o singură goroutină scrie în map.
Repară eroarea, direct în pagină
Programul numără vizitele pe 20000 de pagini din 50 de goroutine (fiecare goroutină vizitează toate paginile o dată), dar toate scriu în același map fără protecție și programul se oprește cu fatal error: concurrent map writes. Protejează map-ul cu un sync.Mutex ca programul să afișeze Pagini: 20000, vizite: 1000000.
package main
import (
"fmt"
"sync"
)
func main() {
vizite := map[int]int{}
var wg sync.WaitGroup
for i := 0; i < 50; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := 0; j < 20000; j++ {
vizite[j]++
}
}()
}
wg.Wait()
total := 0
for _, v := range vizite {
total += v
}
fmt.Printf("Pagini: %d, vizite: %d\n", len(vizite), total)
}Pagini: 20000, vizite: 1000000
Indiciu
Blochează un mutex înainte de fiecare modificare a map-ului și deblochează-l după.
Reparația
package main
import (
"fmt"
"sync"
)
func main() {
vizite := map[int]int{}
var mu sync.Mutex
var wg sync.WaitGroup
for i := 0; i < 50; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := 0; j < 20000; j++ {
mu.Lock()
vizite[j]++
mu.Unlock()
}
}()
}
wg.Wait()
total := 0
for _, v := range vizite {
total += v
}
fmt.Printf("Pagini: %d, vizite: %d\n", len(vizite), total)
}De ce merge
Fără sincronizare, mai multe goroutine modificau map-ul în același timp (inclusiv în timp ce acesta își mărea capacitatea), iar runtime-ul Go oprește programul când detectează asta. Cu mu.Lock() și mu.Unlock() în jurul incrementării, o singură goroutină pe rând modifică map-ul. Așa nu se pierde nicio incrementare: 20000 de pagini, fiecare cu 50 de vizite, adică 1000000 în total.
Alte forme ale mesajului
fatal error: concurrent map read and map writefatal error: concurrent map iteration and map write
Cum o eviți pe viitor
Pentru orice map folosit din mai multe goroutine, pune lângă el un sync.Mutex (de preferat în același struct, cu metode care fac Lock/Unlock) sau folosește sync.Map pentru cache-uri cu multe citiri. Rulează testele cu -race în mod obișnuit, inclusiv în CI. Când poți, evită starea partajată: lasă o singură goroutină proprietară a map-ului și comunică cu ea prin canale.
Întrebări frecvente
De ce programul meu merge uneori?
Pentru că detecția se face doar când două scrieri chiar se suprapun în timp. Cu puține goroutine sau o mașină lentă, suprapunerea poate să nu apară. Bug-ul există oricum, iar -race îl găsește sigur.
Când folosesc sync.Map în loc de map + Mutex?
sync.Map e optimizat pentru chei scrise o dată și citite de multe ori, sau pentru goroutine care lucrează pe chei diferite. Pentru restul cazurilor, map + Mutex e mai simplu și cu tipuri verificate.
Erori înrudite
panic: assignment to entry in nil map Scrii o cheie într-un map care nu a fost creat: e declarat cu var m map[string]int, deci este nil. Un map nil poate fi citit, dar nu poate primi valori. Creează-l cu make(map[string]int) sau cu un literal map[string]int{} înainte de prima scriere. fatal error: sync: unlock of unlocked mutex Ai apelat Unlock pe un mutex care nu era blocat, de obicei pentru că ai deblocat de două ori (un defer mu.Unlock() plus un mu.Unlock() explicit). Păstrează o singură deblocare pentru fiecare Lock, ideal cu defer imediat după Lock. fatal error: all goroutines are asleep - deadlock! Toate goroutinele (inclusiv main) așteaptă la un canal sau la un WaitGroup și niciuna nu mai poate continua. Cauze tipice: trimitere fără receptor pe un canal fără buffer, range peste un canal pe care nu îl închide nimeni, wg.Wait() fără Done() suficiente. Dă fiecărei trimiteri un receptor și închide canalul la final. Învață Go de la zero, cu exerciții la fiecare lecție
Curs Go: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
