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()).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
După close(ch), canalul nu mai acceptă valori noi: orice ch <- v oprește programul cu panic: send on closed channel. Citirea rămâne permisă: întoarce valorile rămase în buffer, apoi valoarea zero cu ok == false.
Problema apare de obicei când mai multe goroutine trimit pe același canal și una dintre ele (sau main) îl închide prea devreme, în timp ce altele încă trimit. Altă cauză: canalul e închis de cel care primește, ca semnal „nu mai vreau date”, dar producătorul nu știe și continuă.
Regula sigură: canalul îl închide cine trimite. Cu mai mulți producători, închiderea se face o singură dată, după ce toți au terminat, de exemplu într-o goroutină separată care așteaptă wg.Wait() și apoi face close(ch).
De ce apare: cauzele frecvente
1Canalul închis înainte de ultima trimitere
ch := make(chan int, 3)
ch <- 1
close(ch)
ch <- 2ch := make(chan int, 3)
ch <- 1
ch <- 2
close(ch)close marchează sfârșitul datelor, deci vine după ultima trimitere.
2Mai mulți producători, închidere prea devreme
for i := 1; i <= 3; i++ {
wg.Add(1)
go func() {
defer wg.Done()
ch <- i
}()
}
close(ch)for i := 1; i <= 3; i++ {
wg.Add(1)
go func() {
defer wg.Done()
ch <- i
}()
}
go func() {
wg.Wait()
close(ch)
}()Canalul se închide doar după ce toate goroutinele producătoare au terminat, semnalat de wg.Wait().
Repară eroarea, direct în pagină
Programul pune lucrările într-o coadă de imprimare (un canal cu buffer), dar se oprește cu panic: send on closed channel. Repară ordinea operațiilor ca programul să afișeze:
Tipăresc: factura.pdf
Tipăresc: contract.pdf
Tipăresc: oferta.pdfpackage main
import "fmt"
func main() {
coada := make(chan string, 3)
coada <- "factura.pdf"
coada <- "contract.pdf"
close(coada)
coada <- "oferta.pdf"
for doc := range coada {
fmt.Println("Tipăresc:", doc)
}
}Tipăresc: factura.pdf Tipăresc: contract.pdf Tipăresc: oferta.pdf
Indiciu
Închide canalul abia după ce ai trimis toate documentele.
Reparația
package main
import "fmt"
func main() {
coada := make(chan string, 3)
coada <- "factura.pdf"
coada <- "contract.pdf"
coada <- "oferta.pdf"
close(coada)
for doc := range coada {
fmt.Println("Tipăresc:", doc)
}
}De ce merge
close(coada) anunță că nu mai vin date, deci orice trimitere după el oprește programul cu panică. Mutat după ultima trimitere, close își face treaba: bufferul conține cele trei documente, iar range le citește în ordine (FIFO) și se termină când canalul închis rămâne gol.
Alte forme ale mesajului
panic: send on closed channel [recovered]
Cum o eviți pe viitor
Stabilește un singur proprietar al canalului, care trimite și îl închide (defer close(ch) în producător). Consumatorii doar citesc, nu închid. Cu mai mulți producători, folosește un WaitGroup și închide canalul după wg.Wait(). Pentru semnalul „oprește-te” trimis producătorilor folosește un canal separat (done) sau un context, nu închiderea canalului de date.
Întrebări frecvente
Cum verific dacă un canal e închis înainte să trimit?
Nu există o verificare sigură: chiar dacă ai afla, canalul s-ar putea închide imediat după. Soluția corectă e să organizezi codul astfel încât doar proprietarul să-l închidă, după ultima trimitere.
Ce se întâmplă la citirea dintr-un canal închis?
Primești valorile rămase în buffer, apoi valoarea zero imediat, fără blocare. Forma v, ok := <-ch îți spune prin ok == false că, de fapt, canalul e închis și gol.
Erori înrudite
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. 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: 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(). Î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.
