panic: sync/atomic: store of inconsistently typed value into Value
Un atomic.Value poate ține un singur tip: după primul Store, toate Store-urile trebuie să fie cu exact același tip concret. Ai pus o dată Config și apoi *Config (sau int și apoi string). Păstrează același tip sau, mai simplu, folosește atomic.Pointer[Config].
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
atomic.Value permite citiri și scrieri sigure între goroutine pentru o valoare înlocuită integral (de obicei o configurare). Primul Store fixează tipul concret, iar fiecare Store ulterior trebuie să aibă același tip; altfel programul se oprește cu panic: sync/atomic: store of inconsistently typed value into Value. Pentru atomic.Value, Config și *Config sunt tipuri diferite, la fel int și int64.
O panică înrudită, store of nil value into Value, apare când încerci să stochezi nil (de exemplu o configurare încă neîncărcată). De la Go 1.19, atomic.Pointer[T] rezolvă ambele probleme: tipul e verificat la compilare și nil este o valoare permisă.
De ce apare: cauzele frecvente
1Valoare la pornire, pointer la reîncărcare
var cfg atomic.Value
cfg.Store(Config{Port: 8080})
// la reîncărcare:
cfg.Store(&Config{Port: 9090})var cfg atomic.Pointer[Config]
cfg.Store(&Config{Port: 8080})
cfg.Store(&Config{Port: 9090})atomic.Pointer[Config] acceptă doar *Config, deci o greșeală de tip nu mai compilează.
2Tipuri numerice amestecate
var v atomic.Value
v.Store(5)
v.Store(int64(6))var v atomic.Int64
v.Store(5)
v.Store(6)Pentru numere există tipuri dedicate (atomic.Int64, atomic.Int32, atomic.Bool), fără any la mijloc.
Repară eroarea, direct în pagină
Programul ține configurarea curentă într-un atomic.Value. La pornire stochează un Config, iar la reîncărcare un *Config, așa că se oprește cu panic: sync/atomic: store of inconsistently typed value into Value. Folosește atomic.Pointer[Config] și stochează mereu pointeri, ca programul să afișeze:
Port: 8080
Port: 9090package main
import (
"fmt"
"sync/atomic"
)
type Config struct {
Port int
}
func main() {
var cfg atomic.Value
cfg.Store(Config{Port: 8080})
fmt.Println("Port:", cfg.Load().(Config).Port)
cfg.Store(&Config{Port: 9090})
fmt.Println("Port:", cfg.Load().(*Config).Port)
}Port: 8080 Port: 9090
Indiciu
var cfg atomic.Pointer[Config], apoi cfg.Store(&Config{...}) și cfg.Load().Port.
Reparația
package main
import (
"fmt"
"sync/atomic"
)
type Config struct {
Port int
}
func main() {
var cfg atomic.Pointer[Config]
cfg.Store(&Config{Port: 8080})
fmt.Println("Port:", cfg.Load().Port)
cfg.Store(&Config{Port: 9090})
fmt.Println("Port:", cfg.Load().Port)
}De ce merge
atomic.Value reține tipul primei valori stocate (Config) și refuză apoi un *Config, chiar dacă reprezintă același lucru. atomic.Pointer[Config] acceptă doar *Config, deci tipul e verificat de compilator, iar Load() întoarce direct un *Config, fără conversia .(Config) care putea și ea să dea panică.
Alte forme ale mesajului
panic: sync/atomic: store of nil value into Valuepanic: sync/atomic: swap of inconsistently typed value into Valuepanic: sync/atomic: compare and swap of inconsistently typed value into Value
Cum o eviți pe viitor
Preferă tipurile atomice cu tip explicit: atomic.Pointer[T] pentru configurări și structuri, atomic.Int64, atomic.Bool pentru contoare și indicatori. Dacă rămâi la atomic.Value, scrie două funcții mici (seteazaConfig(c *Config), config() *Config) și folosește doar acestea, ca tipul stocat să fie mereu același. Când starea are mai multe câmpuri care se schimbă împreună, un sync.Mutex e adesea mai clar.
Întrebări frecvente
De ce Config și *Config sunt considerate tipuri diferite?
Pentru că sunt tipuri diferite în Go: unul este struct-ul, celălalt un pointer la el. atomic.Value compară tipul concret exact, nu „ce reprezintă”.
Când folosesc atomic și când Mutex?
Atomic pentru o singură valoare citită des și înlocuită integral (configurare, contor). Mutex când trebuie să modifici mai multe lucruri împreună sau să faci verificări și modificări în același pas.
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: 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. panic: interface conversion: interface {} is string, not int Ai făcut o aserțiune de tip x.(int) pe o valoare de tip any care conține de fapt un string. Folosește forma cu două valori, v, ok := x.(int), sau un type switch, și tratează cazul în care tipul nu e cel așteptat. Î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.
