Package: sync/atomic

package atomic Import Path sync/atomic (on golang.org and go.dev) Dependency Relation imports one package, and imported by 18 packages

Involved Source Files d➜ doc.go Package atomic provides low-level atomic memory primitives useful for implementing synchronization algorithms. These functions require great care to be used correctly. Except for special, low-level applications, synchronization is better done with channels or the facilities of the sync package. Share memory by communicating; don't communicate by sharing memory. The swap operation, implemented by the SwapT functions, is the atomic equivalent of: old = *addr *addr = new return old The compare-and-swap operation, implemented by the CompareAndSwapT functions, is the atomic equivalent of: if *addr == old { *addr = new return true } return false The add operation, implemented by the AddT functions, is the atomic equivalent of: *addr += delta return *addr The load and store operations, implemented by the LoadT and StoreT functions, are the atomic equivalents of "return *addr" and "*addr = val". value.go asm.s

Code Examples Value_config package main import ( "sync/atomic" "time" ) func loadConfig() map[string]string { return make(map[string]string) } func requests() chan int { return make(chan int) } func main() { var config atomic.Value // holds current server configuration // Create initial config value and store into config. config.Store(loadConfig()) go func() { // Reload config every 10 seconds // and update config value with the new version. for { time.Sleep(10 * time.Second) config.Store(loadConfig()) } }() // Create worker goroutines that handle incoming requests // using the latest config value. for i := 0; i < 10; i++ { go func() { for r := range requests() { c := config.Load() // Handle request r using config c. _, _ = r, c } }() } } Value_readMostly package main import ( "sync" "sync/atomic" ) func main() { type Map map[string]string var m atomic.Value m.Store(make(Map)) var mu sync.Mutex // used only by writers // read function can be used to read the data without further synchronization read := func(key string) (val string) { m1 := m.Load().(Map) return m1[key] } // insert function can be used to update the data without further synchronization insert := func(key, val string) { mu.Lock() // synchronize with other potential writers defer mu.Unlock() m1 := m.Load().(Map) // load current value of the data structure m2 := make(Map) // create a new value for k, v := range m1 { m2[k] = v // copy all data from the current object to the new one } m2[key] = val // do the update that we need m.Store(m2) // atomically replace the current object with the new one // At this point all new readers start working with the new version. // The old version will be garbage collected once the existing readers // (if any) are done with it. } _, _ = read, insert }

Package-Level Type Names (total 2, in which 1 are exported)

/* sort exporteds by: alphabet | popularity */

type Value (struct) A Value provides an atomic load and store of a consistently typed value. The zero value for a Value returns nil from Load. Once Store has been called, a Value must not be copied. A Value must not be copied after first use. Fields (only one, which is unexported) /* one unexported ... *//* one unexported: */ Methods (total 2, both are exported) (*T) Load() (x interface{}) Load returns the value set by the most recent Store. It returns nil if there has been no call to Store for this Value. (*T) Store(x interface{}) Store sets the value of the Value to x. All calls to Store for a given Value must use values of the same concrete type. Store of an inconsistent type panics, as does Store(nil). As Types Of (only one, which is unexported) /* one unexported ... *//* one unexported: */

/* one unexported ... *//* one unexported: */