io: read/write on closed pipe
Ai scris într-un io.Pipe (sau ai citit din el) după ce capătul respectiv a fost închis. Închide PipeWriter-ul abia după ultima scriere, de obicei cu defer pw.Close() în goroutine-ul care scrie, și nu închide cititorul cât timp mai vin date.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
io.Pipe() întoarce două capete legate: ce scrii în *PipeWriter citești din *PipeReader, fără buffer intermediar. Eroarea io.ErrClosedPipe, cu textul io: read/write on closed pipe, apare când folosești un capăt pe care l-ai închis deja: scrii după pw.Close() sau citești după pr.Close().
Cazul tipic: goroutine-ul care produce datele închide writer-ul prea devreme (de exemplu înainte de un rând final sau într-un if de eroare), iar scrierea următoare eșuează. Cititorul vede EOF la închidere și se oprește, deci datele de după se pierd. Dacă cititorul închide (pr.Close()), scrierile primesc tot io: read/write on closed pipe. Același text îl poți vedea și în bibliotecile care folosesc intern pipe-uri (comprimare, upload-uri).
De ce apare: cauzele frecvente
1Close înainte de ultima scriere
go func() {
for _, l := range linii {
fmt.Fprintln(pw, l)
}
pw.Close()
fmt.Fprintln(pw, "TOTAL")
}()go func() {
defer pw.Close()
for _, l := range linii {
fmt.Fprintln(pw, l)
}
fmt.Fprintln(pw, "TOTAL")
}()Cu defer, închiderea se face la ieșirea din goroutine, după toate scrierile.
2Cititorul renunță, iar scriitorul continuă
pr.Close() // am citit doar antetul
// goroutine-ul încă scrie -> eroarepr.CloseWithError(errOprit)
// scriitorul primește errOprit și se opreșteCloseWithError îi transmite scriitorului motivul, iar el poate ieși curat când Write întoarce eroare.
Repară eroarea, direct în pagină
Un goroutine scrie liniile unui raport într-un io.Pipe, iar main le citește pe toate. Linia TOTAL e scrisă după pw.Close(), așa că programul se oprește cu io: read/write on closed pipe. Mută închiderea astfel încât să se facă după ultima scriere, ca programul să afișeze:
mouse 79
tastatura 149
TOTAL 228package main
import (
"fmt"
"io"
)
func main() {
pr, pw := io.Pipe()
errc := make(chan error, 1)
go func() {
fmt.Fprintln(pw, "mouse 79")
fmt.Fprintln(pw, "tastatura 149")
pw.Close()
_, err := fmt.Fprintln(pw, "TOTAL 228")
errc <- err
}()
date, _ := io.ReadAll(pr)
if err := <-errc; err != nil {
panic(err)
}
fmt.Print(string(date))
}mouse 79 tastatura 149 TOTAL 228
Indiciu
Pune defer pw.Close() la începutul goroutine-ului și scoate pw.Close() din mijloc.
Reparația
package main
import (
"fmt"
"io"
)
func main() {
pr, pw := io.Pipe()
errc := make(chan error, 1)
go func() {
defer pw.Close()
fmt.Fprintln(pw, "mouse 79")
fmt.Fprintln(pw, "tastatura 149")
_, err := fmt.Fprintln(pw, "TOTAL 228")
errc <- err
}()
date, _ := io.ReadAll(pr)
if err := <-errc; err != nil {
panic(err)
}
fmt.Print(string(date))
}De ce merge
io.ReadAll citește până când writer-ul e închis. În varianta greșită, pw.Close() venea înainte de TOTAL, deci cititorul se oprea după două linii, iar scrierea următoare primea io.ErrClosedPipe. Cu defer pw.Close(), închiderea se face la ieșirea din goroutine, după ultima scriere, iar ReadAll primește toate cele trei linii.
Cum o eviți pe viitor
Regula pentru pipe-uri: capătul de scriere îl închide doar cine scrie, cu defer pw.Close() (sau pw.CloseWithError(err) când a apărut o eroare) imediat după pornirea goroutine-ului. Verifică eroarea întoarsă de fiecare Write/Fprintln și oprește-te la prima. Dacă cititorul se oprește devreme, folosește CloseWithError, ca scriitorul să afle de ce.
Întrebări frecvente
La ce folosește io.Pipe?
Leagă cod care scrie (un io.Writer, de exemplu un encoder JSON sau un compresor) de cod care citește (un io.Reader, de exemplu corpul unei cereri HTTP), fără să ții toate datele în memorie.
De ce cititorul nu a primit eroare, doar datele incomplete?
Pentru cititor, pw.Close() înseamnă sfârșitul normal al datelor (EOF). Doar scriitorul vede eroarea, la scrierea de după închidere, deci trebuie să o verifici acolo.
Erori înrudite
write raport.txt: file already closed Ai scris sau citit dintr-un *os.File după ce a fost închis cu Close(), de obicei pentru că o funcție ajutătoare are defer f.Close() sau Close e în buclă. Închide fișierul o singură dată, după ultima operație, în funcția care l-a deschis. EOF EOF (io.EOF) înseamnă „s-au terminat datele”, nu o defecțiune. Îl primești de la Read, ReadString, Decode când nu mai e nimic de citit, inclusiv pe ultima linie fără \n. Verifică errors.Is(err, io.EOF) și oprește bucla, după ce procesezi ce s-a citit deja. 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.
