...
Eroare Go · Goroutine și canale

fatal error: concurrent map writes

Pe scurt

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

Greșit
GO
vizite := map[string]int{}
for i := 0; i < 50; i++ {
	go func() {
		vizite["acasa"]++
	}()
}
Corect
GO
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

Greșit
GO
var cache = map[string]string{}

func handler(w http.ResponseWriter, r *http.Request) {
	cache[r.URL.Path] = "..."
}
Corect
GO
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

Greșit
GO
go func(i int) {
	rezultate[i] = calc(i) // map partajat
}(i)
Corect
GO
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 map

Alternativa fără mutex: goroutinele trimit rezultatele pe un canal, iar o singură goroutină scrie în map.

Repară tu

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.

Codul care dă eroarea
GO
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)
}
După reparație, programul afișează
Pagini: 20000, vizite: 1000000
Indiciu

Blochează un mutex înainte de fiecare modificare a map-ului și deblochează-l după.

Alte forme ale mesajului

  • fatal error: concurrent map read and map write
  • fatal 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

← Toate erorile Go

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.