funcAddInt32¶

func AddInt32(addr *int32, deltaint32) (newint32)

AddInt32 atomically adds delta to *addr and returns the new value.Consider using the more ergonomic and less error-proneInt32.Add instead.

funcAddInt64¶

func AddInt64(addr *int64, deltaint64) (newint64)

AddInt64 atomically adds delta to *addr and returns the new value.Consider using the more ergonomic and less error-proneInt64.Add instead(particularly if you target 32-bit platforms; see the bugs section).

funcAddUint32¶

func AddUint32(addr *uint32, deltauint32) (newuint32)

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)).Consider using the more ergonomic and less error-proneUint32.Add instead.

funcAddUint64¶

func AddUint64(addr *uint64, deltauint64) (newuint64)

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)).Consider using the more ergonomic and less error-proneUint64.Add instead(particularly if you target 32-bit platforms; see the bugs section).

funcAddUintptr¶

func AddUintptr(addr *uintptr, deltauintptr) (newuintptr)

AddUintptr atomically adds delta to *addr and returns the new value.Consider using the more ergonomic and less error-proneUintptr.Add instead.

funcAndInt32¶added ingo1.23.0

func AndInt32(addr *int32, maskint32) (oldint32)

AndInt32 atomically performs a bitwise AND operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneInt32.And instead.

funcAndInt64¶added ingo1.23.0

func AndInt64(addr *int64, maskint64) (oldint64)

AndInt64 atomically performs a bitwise AND operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneInt64.And instead.

funcAndUint32¶added ingo1.23.0

func AndUint32(addr *uint32, maskuint32) (olduint32)

AndUint32 atomically performs a bitwise AND operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneUint32.And instead.

funcAndUint64¶added ingo1.23.0

func AndUint64(addr *uint64, maskuint64) (olduint64)

AndUint64 atomically performs a bitwise AND operation on *addr using the bitmask provided as maskand returns the old.Consider using the more ergonomic and less error-proneUint64.And instead.

funcAndUintptr¶added ingo1.23.0

func AndUintptr(addr *uintptr, maskuintptr) (olduintptr)

AndUintptr atomically performs a bitwise AND operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneUintptr.And instead.

funcCompareAndSwapInt32¶

func CompareAndSwapInt32(addr *int32, old, newint32) (swappedbool)

CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.Consider using the more ergonomic and less error-proneInt32.CompareAndSwap instead.

funcCompareAndSwapInt64¶

func CompareAndSwapInt64(addr *int64, old, newint64) (swappedbool)

CompareAndSwapInt64 executes the compare-and-swap operation for an int64 value.Consider using the more ergonomic and less error-proneInt64.CompareAndSwap instead(particularly if you target 32-bit platforms; see the bugs section).

funcCompareAndSwapPointer¶

func CompareAndSwapPointer(addr *unsafe.Pointer, old, newunsafe.Pointer) (swappedbool)

CompareAndSwapPointer executes the compare-and-swap operation for a unsafe.Pointer value.Consider using the more ergonomic and less error-pronePointer.CompareAndSwap instead.

funcCompareAndSwapUint32¶

func CompareAndSwapUint32(addr *uint32, old, newuint32) (swappedbool)

CompareAndSwapUint32 executes the compare-and-swap operation for a uint32 value.Consider using the more ergonomic and less error-proneUint32.CompareAndSwap instead.

funcCompareAndSwapUint64¶

func CompareAndSwapUint64(addr *uint64, old, newuint64) (swappedbool)

CompareAndSwapUint64 executes the compare-and-swap operation for a uint64 value.Consider using the more ergonomic and less error-proneUint64.CompareAndSwap instead(particularly if you target 32-bit platforms; see the bugs section).

funcCompareAndSwapUintptr¶

func CompareAndSwapUintptr(addr *uintptr, old, newuintptr) (swappedbool)

CompareAndSwapUintptr executes the compare-and-swap operation for a uintptr value.Consider using the more ergonomic and less error-proneUintptr.CompareAndSwap instead.

funcLoadInt32¶

func LoadInt32(addr *int32) (valint32)

LoadInt32 atomically loads *addr.Consider using the more ergonomic and less error-proneInt32.Load instead.

funcLoadInt64¶

func LoadInt64(addr *int64) (valint64)

LoadInt64 atomically loads *addr.Consider using the more ergonomic and less error-proneInt64.Load instead(particularly if you target 32-bit platforms; see the bugs section).

funcLoadPointer¶

func LoadPointer(addr *unsafe.Pointer) (valunsafe.Pointer)

LoadPointer atomically loads *addr.Consider using the more ergonomic and less error-pronePointer.Load instead.

funcLoadUint32¶

func LoadUint32(addr *uint32) (valuint32)

LoadUint32 atomically loads *addr.Consider using the more ergonomic and less error-proneUint32.Load instead.

funcLoadUint64¶

func LoadUint64(addr *uint64) (valuint64)

LoadUint64 atomically loads *addr.Consider using the more ergonomic and less error-proneUint64.Load instead(particularly if you target 32-bit platforms; see the bugs section).

funcLoadUintptr¶

func LoadUintptr(addr *uintptr) (valuintptr)

LoadUintptr atomically loads *addr.Consider using the more ergonomic and less error-proneUintptr.Load instead.

funcOrInt32¶added ingo1.23.0

func OrInt32(addr *int32, maskint32) (oldint32)

OrInt32 atomically performs a bitwise OR operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneInt32.Or instead.

funcOrInt64¶added ingo1.23.0

func OrInt64(addr *int64, maskint64) (oldint64)

OrInt64 atomically performs a bitwise OR operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneInt64.Or instead.

funcOrUint32¶added ingo1.23.0

func OrUint32(addr *uint32, maskuint32) (olduint32)

OrUint32 atomically performs a bitwise OR operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneUint32.Or instead.

funcOrUint64¶added ingo1.23.0

func OrUint64(addr *uint64, maskuint64) (olduint64)

OrUint64 atomically performs a bitwise OR operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneUint64.Or instead.

funcOrUintptr¶added ingo1.23.0

func OrUintptr(addr *uintptr, maskuintptr) (olduintptr)

OrUintptr atomically performs a bitwise OR operation on *addr using the bitmask provided as maskand returns the old value.Consider using the more ergonomic and less error-proneUintptr.Or instead.

funcStoreInt32¶

func StoreInt32(addr *int32, valint32)

StoreInt32 atomically stores val into *addr.Consider using the more ergonomic and less error-proneInt32.Store instead.

funcStoreInt64¶

func StoreInt64(addr *int64, valint64)

StoreInt64 atomically stores val into *addr.Consider using the more ergonomic and less error-proneInt64.Store instead(particularly if you target 32-bit platforms; see the bugs section).

funcStorePointer¶

func StorePointer(addr *unsafe.Pointer, valunsafe.Pointer)

StorePointer atomically stores val into *addr.Consider using the more ergonomic and less error-pronePointer.Store instead.

funcStoreUint32¶

func StoreUint32(addr *uint32, valuint32)

StoreUint32 atomically stores val into *addr.Consider using the more ergonomic and less error-proneUint32.Store instead.

funcStoreUint64¶

func StoreUint64(addr *uint64, valuint64)

StoreUint64 atomically stores val into *addr.Consider using the more ergonomic and less error-proneUint64.Store instead(particularly if you target 32-bit platforms; see the bugs section).

funcStoreUintptr¶

func StoreUintptr(addr *uintptr, valuintptr)

StoreUintptr atomically stores val into *addr.Consider using the more ergonomic and less error-proneUintptr.Store instead.

funcSwapInt32¶added ingo1.2

func SwapInt32(addr *int32, newint32) (oldint32)

SwapInt32 atomically stores new into *addr and returns the previous *addr value.Consider using the more ergonomic and less error-proneInt32.Swap instead.

funcSwapInt64¶added ingo1.2

func SwapInt64(addr *int64, newint64) (oldint64)

SwapInt64 atomically stores new into *addr and returns the previous *addr value.Consider using the more ergonomic and less error-proneInt64.Swap instead(particularly if you target 32-bit platforms; see the bugs section).

funcSwapPointer¶added ingo1.2

func SwapPointer(addr *unsafe.Pointer, newunsafe.Pointer) (oldunsafe.Pointer)

SwapPointer atomically stores new into *addr and returns the previous *addr value.Consider using the more ergonomic and less error-pronePointer.Swap instead.

funcSwapUint32¶added ingo1.2

func SwapUint32(addr *uint32, newuint32) (olduint32)

SwapUint32 atomically stores new into *addr and returns the previous *addr value.Consider using the more ergonomic and less error-proneUint32.Swap instead.

funcSwapUint64¶added ingo1.2

func SwapUint64(addr *uint64, newuint64) (olduint64)

SwapUint64 atomically stores new into *addr and returns the previous *addr value.Consider using the more ergonomic and less error-proneUint64.Swap instead(particularly if you target 32-bit platforms; see the bugs section).

funcSwapUintptr¶added ingo1.2

func SwapUintptr(addr *uintptr, newuintptr) (olduintptr)

SwapUintptr atomically stores new into *addr and returns the previous *addr value.Consider using the more ergonomic and less error-proneUintptr.Swap instead.

typeBool¶added ingo1.19

type Bool struct {// contains filtered or unexported fields}

A Bool is an atomic boolean value.The zero value is false.

func (x *Bool) CompareAndSwap(old, newbool) (swappedbool)

func (x *Bool) Load()bool

func (x *Bool) Store(valbool)

func (x *Bool) Swap(newbool) (oldbool)

typeInt32¶added ingo1.19

type Int32 struct {// contains filtered or unexported fields}

An Int32 is an atomic int32. The zero value is zero.

func (x *Int32) Add(deltaint32) (newint32)

func (x *Int32) And(maskint32) (oldint32)

func (x *Int32) CompareAndSwap(old, newint32) (swappedbool)

func (x *Int32) Load()int32

func (x *Int32) Or(maskint32) (oldint32)

func (x *Int32) Store(valint32)

func (x *Int32) Swap(newint32) (oldint32)

typeInt64¶added ingo1.19

type Int64 struct {// contains filtered or unexported fields}

An Int64 is an atomic int64. The zero value is zero.

func (x *Int64) Add(deltaint64) (newint64)

func (x *Int64) And(maskint64) (oldint64)

func (x *Int64) CompareAndSwap(old, newint64) (swappedbool)

func (x *Int64) Load()int64

func (x *Int64) Or(maskint64) (oldint64)

func (x *Int64) Store(valint64)

func (x *Int64) Swap(newint64) (oldint64)

typePointer¶added ingo1.19

type Pointer[Tany] struct {// contains filtered or unexported fields}

A Pointer is an atomic pointer of type *T. The zero value is a nil *T.

func (x *Pointer[T]) CompareAndSwap(old, new *T) (swappedbool)

func (x *Pointer[T]) Load() *T

func (x *Pointer[T]) Store(val *T)

func (x *Pointer[T]) Swap(new *T) (old *T)

typeUint32¶added ingo1.19

type Uint32 struct {// contains filtered or unexported fields}

A Uint32 is an atomic uint32. The zero value is zero.

func (x *Uint32) Add(deltauint32) (newuint32)

func (x *Uint32) And(maskuint32) (olduint32)

func (x *Uint32) CompareAndSwap(old, newuint32) (swappedbool)

func (x *Uint32) Load()uint32

func (x *Uint32) Or(maskuint32) (olduint32)

func (x *Uint32) Store(valuint32)

func (x *Uint32) Swap(newuint32) (olduint32)

typeUint64¶added ingo1.19

type Uint64 struct {// contains filtered or unexported fields}

A Uint64 is an atomic uint64. The zero value is zero.

func (x *Uint64) Add(deltauint64) (newuint64)

func (x *Uint64) And(maskuint64) (olduint64)

func (x *Uint64) CompareAndSwap(old, newuint64) (swappedbool)

func (x *Uint64) Load()uint64

func (x *Uint64) Or(maskuint64) (olduint64)

func (x *Uint64) Store(valuint64)

func (x *Uint64) Swap(newuint64) (olduint64)

typeUintptr¶added ingo1.19

type Uintptr struct {// contains filtered or unexported fields}

A Uintptr is an atomic uintptr. The zero value is zero.

func (x *Uintptr) Add(deltauintptr) (newuintptr)

func (x *Uintptr) And(maskuintptr) (olduintptr)

func (x *Uintptr) CompareAndSwap(old, newuintptr) (swappedbool)

func (x *Uintptr) Load()uintptr

func (x *Uintptr) Or(maskuintptr) (olduintptr)

func (x *Uintptr) Store(valuintptr)

func (x *Uintptr) Swap(newuintptr) (olduintptr)

typeValue¶added ingo1.4

type Value struct {// contains filtered or unexported fields}

A Value provides an atomic load and store of a consistently typed value.The zero value for a Value returns nil fromValue.Load.OnceValue.Store has been called, a Value must not be copied.

A Value must not be copied after first use.

package mainimport ("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 mainimport ("sync""sync/atomic")func main() {type Map map[string]stringvar m atomic.Valuem.Store(make(Map))var mu sync.Mutex // used only by writers// read function can be used to read the data without further synchronizationread := func(key string) (val string) {m1 := m.Load().(Map)return m1[key]}// insert function can be used to update the data without further synchronizationinsert := func(key, val string) {mu.Lock() // synchronize with other potential writersdefer mu.Unlock()m1 := m.Load().(Map) // load current value of the data structurem2 := make(Map)      // create a new valuefor 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 needm.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}

func (v *Value) CompareAndSwap(old, newany) (swappedbool)

func (v *Value) Load() (valany)

func (v *Value) Store(valany)

func (v *Value) Swap(newany) (oldany)

Bugs¶

• On 386, the 64-bit functions use instructions unavailable before the Pentium MMX.

  On non-Linux ARM, the 64-bit functions use instructions unavailable before the ARMv6k core.

  On ARM, 386, and 32-bit MIPS, it is the caller's responsibility to arrangefor 64-bit alignment of 64-bit words accessed atomically via the primitiveatomic functions (typesInt64 andUint64 are automatically aligned).The first word in an allocated struct, array, or slice; in a globalvariable; or in a local variable (because on 32-bit architectures, thesubject of 64-bit atomic operations will escape to the heap) can berelied upon to be 64-bit aligned.