package atomic

Import Path
	sync/atomic (on go.dev)

Dependency Relation
	imports one package, and imported by 10 packages


Involved Source Files

	
		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

	
		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
					}
				}()
			}
		}

	
		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:  |  */
	
		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.

		
			
		
			
				Load returns the value set by the most recent Store.
				It returns nil if there has been no call to Store for this Value.

			
				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).

		
			


	


Package-Level Functions (total 31, in which 29 are exported)


	
		AddInt32 atomically adds delta to *addr and returns the new value.


	
		AddInt64 atomically adds delta to *addr and returns the new value.


	
		AddUint32 atomically adds delta to *addr and returns the new value.
		To subtract a signed positive constant value c from x, do AddUint32(&x, ^uint32(c-1)).
		In particular, to decrement x, do AddUint32(&x, ^uint32(0)).


	
		AddUint64 atomically adds delta to *addr and returns the new value.
		To subtract a signed positive constant value c from x, do AddUint64(&x, ^uint64(c-1)).
		In particular, to decrement x, do AddUint64(&x, ^uint64(0)).


	
		AddUintptr atomically adds delta to *addr and returns the new value.


	
		CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.


	
		CompareAndSwapInt64 executes the compare-and-swap operation for an int64 value.


	
		CompareAndSwapPointer executes the compare-and-swap operation for a unsafe.Pointer value.


	
		CompareAndSwapUint32 executes the compare-and-swap operation for a uint32 value.


	
		CompareAndSwapUint64 executes the compare-and-swap operation for a uint64 value.


	
		CompareAndSwapUintptr executes the compare-and-swap operation for a uintptr value.


	
		LoadInt32 atomically loads *addr.


	
		LoadInt64 atomically loads *addr.


	
		LoadPointer atomically loads *addr.


	
		LoadUint32 atomically loads *addr.


	
		LoadUint64 atomically loads *addr.


	
		LoadUintptr atomically loads *addr.


	
		StoreInt32 atomically stores val into *addr.


	
		StoreInt64 atomically stores val into *addr.


	
		StorePointer atomically stores val into *addr.


	
		StoreUint32 atomically stores val into *addr.


	
		StoreUint64 atomically stores val into *addr.


	
		StoreUintptr atomically stores val into *addr.


	
		SwapInt32 atomically stores new into *addr and returns the previous *addr value.


	
		SwapInt64 atomically stores new into *addr and returns the previous *addr value.


	
		SwapPointer atomically stores new into *addr and returns the previous *addr value.


	
		SwapUint32 atomically stores new into *addr and returns the previous *addr value.


	
		SwapUint64 atomically stores new into *addr and returns the previous *addr value.


	
		SwapUintptr atomically stores new into *addr and returns the previous *addr value.