panic: sync: negative WaitGroup counter
Ai apelat wg.Done() de mai multe ori decât wg.Add(...). Contorul WaitGroup a scăzut sub zero. Apelează wg.Add(1) o dată pentru fiecare goroutină pornită și wg.Done() o singură dată în fiecare, de preferat cu defer wg.Done().
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
sync.WaitGroup are un contor intern: Add(n) îl crește, Done() îl scade cu 1, iar Wait() blochează până ajunge la 0. Dacă Done() este apelat mai des decât s-a adunat cu Add, contorul ar deveni negativ, iar Go oprește programul cu panic: sync: negative WaitGroup counter.
Cauze frecvente: Done() apelat de două ori în aceeași goroutină (o dată explicit, o dată cu defer); Add(1) uitat pentru una dintre goroutine; Add cu un număr mai mic decât numărul real de goroutine; sau același WaitGroup refolosit greșit.
Situația inversă, mai multe Add decât Done, nu dă panică, ci blochează Wait() (și de obicei se termină cu all goroutines are asleep - deadlock!). Când Done() în plus vine chiar în timp ce main se trezește din Wait(), poți vedea și mesajul înrudit sync: WaitGroup is reused before previous Wait has returned.
De ce apare: cauzele frecvente
1Done apelat de două ori
wg.Add(1)
go func() {
defer wg.Done()
calculeaza()
wg.Done()
}()wg.Add(1)
go func() {
defer wg.Done()
calculeaza()
}()defer wg.Done() se execută deja la ieșirea din funcție. Al doilea Done() scade contorul sub zero.
2Add cu un număr prea mic
magazine := []string{"Cluj", "Iași", "Brașov"}
wg.Add(1)
for _, m := range magazine {
go func() {
defer wg.Done()
fmt.Println(m)
}()
}magazine := []string{"Cluj", "Iași", "Brașov"}
for _, m := range magazine {
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println(m)
}()
}Fiecare goroutină face un Done(), deci fiecare are nevoie de propriul Add(1), pus chiar înainte de go.
3wg.Go din Go 1.25
for _, m := range magazine {
go func() {
defer wg.Done()
proceseaza(m)
}()
}for _, m := range magazine {
wg.Go(func() {
proceseaza(m)
})
}wg.Go(f) face singur Add(1) și Done(), deci nu mai poți greși perechile.
Repară eroarea, direct în pagină
Programul adună într-o goroutină de fundal vânzările a trei magazine, iar main așteaptă rezultatul cu un WaitGroup. Programul se oprește cu panic: sync: negative WaitGroup counter. Repară folosirea WaitGroup ca programul să afișeze Total vânzări: 6000 lei.
package main
import (
"fmt"
"sync"
)
func main() {
vanzari := []int{1500, 2000, 2500}
total := 0
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
for _, v := range vanzari {
total += v
}
wg.Done()
}()
wg.Wait()
fmt.Printf("Total vânzări: %d lei\n", total)
}Total vânzări: 6000 lei
Indiciu
Goroutina face un singur Add(1), deci are voie la un singur Done(); elimină apelul în plus.
Reparația
package main
import (
"fmt"
"sync"
)
func main() {
vanzari := []int{1500, 2000, 2500}
total := 0
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
for _, v := range vanzari {
total += v
}
}()
wg.Wait()
fmt.Printf("Total vânzări: %d lei\n", total)
}De ce merge
Goroutina apela Done() de două ori: o dată explicit, la final, și încă o dată prin defer, la ieșire. Contorul, crescut o singură dată cu Add(1), cobora la -1, iar Go oprea programul. Cu un singur defer wg.Done(), Add și Done sunt în pereche, Wait() se deblochează după ce goroutina a terminat suma, iar main afișează 1500 + 2000 + 2500 = 6000. defer e varianta preferată: Done() se execută și dacă funcția iese mai devreme.
Alte forme ale mesajului
panic: sync: negative WaitGroup counter [recovered]panic: sync: WaitGroup is reused before previous Wait has returned
Cum o eviți pe viitor
Folosește tiparul fix: wg.Add(1) imediat înainte de go func() și defer wg.Done() ca primă linie în goroutină, fără alte apeluri Done. În Go 1.25 și mai nou, wg.Go(func() { ... }) face totul automat. Nu copia un WaitGroup (trimite-l ca pointer, *sync.WaitGroup, dacă îl dai unei funcții).
Întrebări frecvente
De ce trebuie Add înainte de go, nu în goroutină?
Dacă Add este în goroutină, main poate ajunge la Wait() înainte ca goroutina să pornească, vede contorul 0 și continuă prea devreme. Add înainte de go garantează ordinea.
De ce trimit WaitGroup ca pointer?
Un WaitGroup copiat are propriul contor. Done() pe copie nu afectează originalul, iar Wait() din main așteaptă la nesfârșit. go vet te avertizează la astfel de copii.
Erori înrudite
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. panic: close of closed channel Ai apelat close pe un canal deja închis. Un canal se poate închide o singură dată. Lasă închiderea în grija unei singure goroutine (cea care trimite) sau protejeaz-o cu sync.Once dacă mai multe locuri ar putea-o face. panic: send on closed channel Ai trimis o valoare pe un canal după ce a fost închis cu close. Un canal închis poate fi citit, dar nu mai acceptă trimiteri. Închide canalul o singură dată, doar după ce toți cei care trimit au terminat (de regulă de către cel care trimite, sau după wg.Wait()). Î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.
