fatal error: sync: unlock of unlocked mutex
Ai apelat Unlock pe un mutex care nu era blocat, de obicei pentru că ai deblocat de două ori (un defer mu.Unlock() plus un mu.Unlock() explicit). Păstrează o singură deblocare pentru fiecare Lock, ideal cu defer imediat după Lock.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Fiecare mu.Lock() trebuie urmat de exact un mu.Unlock(). Dacă deblochezi un mutex care e deja liber, Go consideră că starea programului e coruptă și îl oprește cu fatal error: sync: unlock of unlocked mutex. Fiind o eroare fatală, nu poate fi prinsă cu recover.
Pentru sync.RWMutex mesajele sunt fatal error: sync: Unlock of unlocked RWMutex și fatal error: sync: RUnlock of unlocked RWMutex (ai deblocat cu RUnlock fără RLock, sau ai amestecat RLock cu Unlock).
Cauzele frecvente: defer mu.Unlock() combinat cu un Unlock explicit pe o ramură (de exemplu înainte de return), Unlock într-o funcție care nu a făcut Lock, sau un mutex copiat (struct transmis prin valoare), astfel că blochezi o copie și deblochezi alta.
De ce apare: cauzele frecvente
1defer plus Unlock explicit
mu.Lock()
defer mu.Unlock()
if sold < suma {
mu.Unlock()
return errors.New("fonduri insuficiente")
}mu.Lock()
defer mu.Unlock()
if sold < suma {
return errors.New("fonduri insuficiente")
}defer deblochează deja la ieșirea din funcție, pe orice ramură.
2RUnlock după Lock
mu.Lock()
defer mu.RUnlock()mu.Lock()
defer mu.Unlock()Perechile trebuie să se potrivească: Lock/Unlock și RLock/RUnlock.
3Mutex copiat prin receptor valoare
func (c Contor) Inc() {
c.mu.Lock()
defer c.mu.Unlock()
c.n++
}func (c *Contor) Inc() {
c.mu.Lock()
defer c.mu.Unlock()
c.n++
}Cu receptor valoare, fiecare apel lucrează pe o copie a mutex-ului. go vet (analizorul copylocks) semnalează asta.
Repară eroarea, direct în pagină
Metoda Retrage deblochează mutex-ul și cu defer, și explicit pe ramura de eroare, iar programul se oprește cu fatal error: sync: unlock of unlocked mutex. Păstrează o singură deblocare ca programul să afișeze:
Eroare: fonduri insuficiente
Sold: 100package main
import (
"errors"
"fmt"
"sync"
)
type Cont struct {
mu sync.Mutex
sold int
}
func (c *Cont) Retrage(suma int) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.sold < suma {
c.mu.Unlock()
return errors.New("fonduri insuficiente")
}
c.sold -= suma
return nil
}
func main() {
c := &Cont{sold: 100}
if err := c.Retrage(500); err != nil {
fmt.Println("Eroare:", err)
}
fmt.Println("Sold:", c.sold)
}Eroare: fonduri insuficiente Sold: 100
Indiciu
defer mu.Unlock() deblochează deja la ieșirea din funcție; scoate Unlock-ul explicit.
Reparația
package main
import (
"errors"
"fmt"
"sync"
)
type Cont struct {
mu sync.Mutex
sold int
}
func (c *Cont) Retrage(suma int) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.sold < suma {
return errors.New("fonduri insuficiente")
}
c.sold -= suma
return nil
}
func main() {
c := &Cont{sold: 100}
if err := c.Retrage(500); err != nil {
fmt.Println("Eroare:", err)
}
fmt.Println("Sold:", c.sold)
}De ce merge
Pe ramura de eroare, mutex-ul era deblocat o dată explicit și încă o dată de defer la ieșirea din funcție. A doua deblocare găsea mutex-ul deja liber și oprea programul. Fără Unlock-ul explicit, defer face o singură deblocare pe orice ramură, iar retragerea refuzată lasă soldul neschimbat, 100.
Alte forme ale mesajului
fatal error: sync: Unlock of unlocked RWMutexfatal error: sync: RUnlock of unlocked RWMutex
Cum o eviți pe viitor
Scrie defer mu.Unlock() pe linia imediat după mu.Lock() și nu mai debloca manual în aceeași funcție. Dacă ai nevoie să deblochezi mai devreme, mută zona protejată într-o funcție separată cu propriul defer. Pune mutex-ul în struct lângă datele pe care le protejează și folosește receptori pointer. Rulează go vet, care prinde mutex-urile copiate.
Întrebări frecvente
De ce nu e doar o panică pe care o pot prinde?
Pentru că un mutex deblocat greșit înseamnă că altă goroutină ar putea fi deja în zona protejată. Go preferă să oprească totul decât să continue cu date posibil corupte.
Pot debloca dintr-o altă goroutină decât cea care a blocat?
Da, sync.Mutex nu e legat de goroutină. Dar e greu de urmărit; în aproape toate cazurile e mai clar ca aceeași funcție să facă Lock și Unlock.
Erori înrudite
fatal error: concurrent map writes 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. 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. expression in defer must be function call După defer (și după go) trebuie să fie un apel de funcție, cu paranteze: defer f.Close(), nu defer f.Close. Adaugă parantezele și argumentele, sau învelește codul într-o funcție anonimă: defer func() { ... }(). Î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.
