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.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Runtime-ul Go observă că nicio goroutină nu mai poate face progres: toate sunt blocate în operații care nu se vor termina niciodată. Atunci oprește programul cu fatal error: all goroutines are asleep - deadlock!. Sub mesaj vezi fiecare goroutină și motivul blocării: goroutine 1 [chan send]: (trimitere), [chan receive] (citire), [sync.WaitGroup.Wait] sau [select (no cases)], cu linia din cod.
Un canal fără buffer (make(chan int)) blochează trimiterea până când altă goroutină citește. Dacă main trimite și tot main ar urma să citească, nu se mai ajunge niciodată la citire. for v := range ch citește până când canalul e închis; dacă nimeni nu face close(ch), bucla așteaptă la nesfârșit.
Atenție: detectorul vede doar blocajul total. Dacă o altă goroutină încă rulează, programul pur și simplu se blochează, fără mesaj.
De ce apare: cauzele frecvente
1Trimitere pe un canal fără buffer, fără receptor
ch := make(chan int)
ch <- 42
fmt.Println(<-ch)ch := make(chan int)
go func() {
ch <- 42
}()
fmt.Println(<-ch)Trimiterea blochează până la citire. Mutată într-o goroutină, main ajunge la <-ch și cele două se întâlnesc.
2range peste un canal care nu e închis
ch := make(chan int)
go func() {
for i := 1; i <= 3; i++ {
ch <- i
}
}()
for v := range ch {
fmt.Println(v)
}ch := make(chan int)
go func() {
defer close(ch)
for i := 1; i <= 3; i++ {
ch <- i
}
}()
for v := range ch {
fmt.Println(v)
}După ultimul element, range așteaptă alte valori. close(ch) îi semnalează că nu mai vine nimic, iar bucla se termină.
3wg.Wait fără Done corespunzător
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
fmt.Println("lucrez")
}()
wg.Wait()var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("lucrez")
}()
wg.Wait()Add(2) cere două Done(), dar pornește o singură goroutină. Numărul din Add trebuie să fie egal cu numărul de goroutine care apelează Done.
4Lock de două ori pe același Mutex
var mu sync.Mutex
mu.Lock()
mu.Lock()var mu sync.Mutex
mu.Lock()
// ... lucru cu datele comune
mu.Unlock()sync.Mutex nu este reentrant: a doua blocare din aceeași goroutină așteaptă la nesfârșit. Folosește defer mu.Unlock() imediat după Lock().
Repară eroarea, direct în pagină
Programul trimite trei comenzi unui consumator printr-un canal, dar se oprește cu fatal error: all goroutines are asleep - deadlock!. Repară producătorul ca programul să afișeze:
Procesez comanda 101
Procesez comanda 102
Procesez comanda 103
Gatapackage main
import "fmt"
func main() {
comenzi := make(chan int)
go func() {
for _, id := range []int{101, 102, 103} {
comenzi <- id
}
}()
for c := range comenzi {
fmt.Println("Procesez comanda", c)
}
fmt.Println("Gata")
}Procesez comanda 101 Procesez comanda 102 Procesez comanda 103 Gata
Indiciu
Bucla for c := range comenzi se termină doar când canalul este închis; producătorul trebuie să facă close.
Reparația
package main
import "fmt"
func main() {
comenzi := make(chan int)
go func() {
defer close(comenzi)
for _, id := range []int{101, 102, 103} {
comenzi <- id
}
}()
for c := range comenzi {
fmt.Println("Procesez comanda", c)
}
fmt.Println("Gata")
}De ce merge
După cele trei comenzi, goroutina producătoare se termina, iar main rămânea în range, așteptând o a patra valoare care nu mai venea. Nicio goroutină nu mai putea continua, așa că runtime-ul a oprit programul. defer close(comenzi) închide canalul când producătorul termină, iar range iese din buclă după ultima valoare. Regula: închide canalul cel care trimite, nu cel care primește.
Alte forme ale mesajului
fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan send]:goroutine 1 [chan receive]:goroutine 1 [sync.WaitGroup.Wait]:
Cum o eviți pe viitor
Pentru fiecare canal stabilește de la început cine trimite, cine primește și cine îl închide (de regulă cel care trimite, cu defer close(ch)). Nu trimite și nu primi pe același canal fără buffer din aceeași goroutină. Apelează wg.Add(1) înainte de fiecare go func() și defer wg.Done() ca primă linie în ea. Pentru o singură valoare „gata” poți folosi un canal cu buffer 1 (make(chan T, 1)).
Întrebări frecvente
Un canal cu buffer rezolvă deadlock-ul?
Uneori: make(chan int, 1) permite o trimitere fără receptor. Dar dacă trimiți mai multe valori decât încap, blocarea revine. Bufferul e o soluție doar când știi exact câte valori se trimit.
De ce programul meu se blochează fără niciun mesaj?
Detectorul de deadlock acționează doar când absolut toate goroutinele sunt blocate. Dacă una încă rulează (de exemplu un time.Sleep sau o buclă), programul așteaptă la nesfârșit fără eroare.
Cum citesc stiva de sub mesaj?
Caută goroutine N [motiv]: urmat de funcția și linia ta (main.go:12). Motivul (chan send, chan receive, sync.WaitGroup.Wait) îți spune ce operație s-a blocat.
Erori înrudite
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()). 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(). 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. Î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.
