sync/atomic
import "sync/atomic"
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 ...
Go 1.26.1
Functions
func AddInt32(addr *int32, delta int32) int32
AddInt32 atomically adds delta to *addr and returns the new value. Consider using the more ergonomic and less error-prone [Int32.Add] instead.
sync/atomic/doc.go:115
func AddInt64(addr *int64, delta int64) int64
AddInt64 atomically adds delta to *addr and returns the new value. Consider using the more ergonomic and less error-prone [Int64.Add] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:42
func AddUint32(addr *uint32, delta uint32) uint32
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-prone [Uint32.Add] instead.
sync/atomic/doc.go:123
func AddUint64(addr *uint64, delta uint64) uint64
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-prone [Uint64.Add] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:51
func AddUintptr(addr *uintptr, delta uintptr) uintptr
AddUintptr atomically adds delta to *addr and returns the new value. Consider using the more ergonomic and less error-prone [Uintptr.Add] instead.
sync/atomic/doc.go:129
func AndInt32(addr *int32, mask int32) int32
AndInt32 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Int32.And] instead.
sync/atomic/doc.go:136
func AndInt64(addr *int64, mask int64) int64
AndInt64 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Int64.And] instead.
sync/atomic/doc_64.go:58
func AndUint32(addr *uint32, mask uint32) uint32
AndUint32 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Uint32.And] instead.
sync/atomic/doc.go:143
func AndUint64(addr *uint64, mask uint64) uint64
AndUint64 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask and returns the old. Consider using the more ergonomic and less error-prone [Uint64.And] instead.
sync/atomic/doc_64.go:65
func AndUintptr(addr *uintptr, mask uintptr) uintptr
AndUintptr atomically performs a bitwise AND operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Uintptr.And] instead.
sync/atomic/doc.go:150
func CompareAndSwapInt32(addr *int32, old int32, new int32) bool
CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value. Consider using the more ergonomic and less error-prone [Int32.CompareAndSwap] instead.
sync/atomic/doc.go:93
func CompareAndSwapInt64(addr *int64, old int64, new int64) bool
CompareAndSwapInt64 executes the compare-and-swap operation for an int64 value. Consider using the more ergonomic and less error-prone [Int64.CompareAndSwap] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:28
func CompareAndSwapPointer(addr *unsafe.Pointer, old unsafe.Pointer, new unsafe.Pointer) bool
CompareAndSwapPointer executes the compare-and-swap operation for a unsafe.Pointer value. Consider using the more ergonomic and less error-prone [Pointer.CompareAndSwap] instead.
sync/atomic/doc.go:109
func CompareAndSwapUint32(addr *uint32, old uint32, new uint32) bool
CompareAndSwapUint32 executes the compare-and-swap operation for a uint32 value. Consider using the more ergonomic and less error-prone [Uint32.CompareAndSwap] instead.
sync/atomic/doc.go:99
func CompareAndSwapUint64(addr *uint64, old uint64, new uint64) bool
CompareAndSwapUint64 executes the compare-and-swap operation for a uint64 value. Consider using the more ergonomic and less error-prone [Uint64.CompareAndSwap] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:35
func CompareAndSwapUintptr(addr *uintptr, old uintptr, new uintptr) bool
CompareAndSwapUintptr executes the compare-and-swap operation for a uintptr value. Consider using the more ergonomic and less error-prone [Uintptr.CompareAndSwap] instead.
sync/atomic/doc.go:105
func LoadInt32(addr *int32) int32
LoadInt32 atomically loads *addr. Consider using the more ergonomic and less error-prone [Int32.Load] instead.
sync/atomic/doc.go:177
func LoadInt64(addr *int64) int64
LoadInt64 atomically loads *addr. Consider using the more ergonomic and less error-prone [Int64.Load] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:86
func LoadPointer(addr *unsafe.Pointer) unsafe.Pointer
LoadPointer atomically loads *addr. Consider using the more ergonomic and less error-prone [Pointer.Load] instead.
sync/atomic/doc.go:193
func LoadUint32(addr *uint32) uint32
LoadUint32 atomically loads *addr. Consider using the more ergonomic and less error-prone [Uint32.Load] instead.
sync/atomic/doc.go:183
func LoadUint64(addr *uint64) uint64
LoadUint64 atomically loads *addr. Consider using the more ergonomic and less error-prone [Uint64.Load] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:93
func LoadUintptr(addr *uintptr) uintptr
LoadUintptr atomically loads *addr. Consider using the more ergonomic and less error-prone [Uintptr.Load] instead.
sync/atomic/doc.go:189
func OrInt32(addr *int32, mask int32) int32
OrInt32 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Int32.Or] instead.
sync/atomic/doc.go:157
func OrInt64(addr *int64, mask int64) int64
OrInt64 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Int64.Or] instead.
sync/atomic/doc_64.go:72
func OrUint32(addr *uint32, mask uint32) uint32
OrUint32 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Uint32.Or] instead.
sync/atomic/doc.go:164
func OrUint64(addr *uint64, mask uint64) uint64
OrUint64 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Uint64.Or] instead.
sync/atomic/doc_64.go:79
func OrUintptr(addr *uintptr, mask uintptr) uintptr
OrUintptr atomically performs a bitwise OR operation on *addr using the bitmask provided as mask and returns the old value. Consider using the more ergonomic and less error-prone [Uintptr.Or] instead.
sync/atomic/doc.go:171
func StoreInt32(addr *int32, val int32)
StoreInt32 atomically stores val into *addr. Consider using the more ergonomic and less error-prone [Int32.Store] instead.
sync/atomic/doc.go:199
func StoreInt64(addr *int64, val int64)
StoreInt64 atomically stores val into *addr. Consider using the more ergonomic and less error-prone [Int64.Store] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:100
func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)
StorePointer atomically stores val into *addr. Consider using the more ergonomic and less error-prone [Pointer.Store] instead.
sync/atomic/doc.go:215
func StoreUint32(addr *uint32, val uint32)
StoreUint32 atomically stores val into *addr. Consider using the more ergonomic and less error-prone [Uint32.Store] instead.
sync/atomic/doc.go:205
func StoreUint64(addr *uint64, val uint64)
StoreUint64 atomically stores val into *addr. Consider using the more ergonomic and less error-prone [Uint64.Store] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:107
func StoreUintptr(addr *uintptr, val uintptr)
StoreUintptr atomically stores val into *addr. Consider using the more ergonomic and less error-prone [Uintptr.Store] instead.
sync/atomic/doc.go:211
func SwapInt32(addr *int32, new int32) int32
SwapInt32 atomically stores new into *addr and returns the previous *addr value. Consider using the more ergonomic and less error-prone [Int32.Swap] instead.
sync/atomic/doc.go:71
func SwapInt64(addr *int64, new int64) int64
SwapInt64 atomically stores new into *addr and returns the previous *addr value. Consider using the more ergonomic and less error-prone [Int64.Swap] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:14
func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
SwapPointer atomically stores new into *addr and returns the previous *addr value. Consider using the more ergonomic and less error-prone [Pointer.Swap] instead.
sync/atomic/doc.go:87
func SwapUint32(addr *uint32, new uint32) uint32
SwapUint32 atomically stores new into *addr and returns the previous *addr value. Consider using the more ergonomic and less error-prone [Uint32.Swap] instead.
sync/atomic/doc.go:77
func SwapUint64(addr *uint64, new uint64) uint64
SwapUint64 atomically stores new into *addr and returns the previous *addr value. Consider using the more ergonomic and less error-prone [Uint64.Swap] instead (particularly if you target 32-bit platforms; see the bugs section).
sync/atomic/doc_64.go:21
func SwapUintptr(addr *uintptr, new uintptr) uintptr
SwapUintptr atomically stores new into *addr and returns the previous *addr value. Consider using the more ergonomic and less error-prone [Uintptr.Swap] instead.
sync/atomic/doc.go:83
Types
type Bool struct {
// contains filtered or unexported fields
}A Bool is an atomic boolean value. The zero value is false. Bool must not be copied after first use.
sync/atomic/type.go:13
func (x *Bool) CompareAndSwap(old bool, new bool) bool
CompareAndSwap executes the compare-and-swap operation for the boolean value x.
sync/atomic/type.go:28
func (x *Bool) Load() bool
Load atomically loads and returns the value stored in x.
sync/atomic/type.go:19
func (x *Bool) Store(val bool)
Store atomically stores val into x.
sync/atomic/type.go:22
func (x *Bool) Swap(new bool) bool
Swap atomically stores new into x and returns the previous value.
sync/atomic/type.go:25
type Int32 struct {
// contains filtered or unexported fields
}An Int32 is an atomic int32. The zero value is zero. Int32 must not be copied after first use.
sync/atomic/type.go:74
func (x *Int32) Add(delta int32) int32
Add atomically adds delta to x and returns the new value.
sync/atomic/type.go:94
func (x *Int32) And(mask int32) int32
And atomically performs a bitwise AND operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:98
func (x *Int32) CompareAndSwap(old int32, new int32) bool
CompareAndSwap executes the compare-and-swap operation for x.
sync/atomic/type.go:89
func (x *Int32) Load() int32
Load atomically loads and returns the value stored in x.
sync/atomic/type.go:80
func (x *Int32) Or(mask int32) int32
Or atomically performs a bitwise OR operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:102
func (x *Int32) Store(val int32)
Store atomically stores val into x.
sync/atomic/type.go:83
func (x *Int32) Swap(new int32) int32
Swap atomically stores new into x and returns the previous value.
sync/atomic/type.go:86
type Int64 struct {
// contains filtered or unexported fields
}An Int64 is an atomic int64. The zero value is zero. Int64 must not be copied after first use.
sync/atomic/type.go:107
func (x *Int64) Add(delta int64) int64
Add atomically adds delta to x and returns the new value.
sync/atomic/type.go:128
func (x *Int64) And(mask int64) int64
And atomically performs a bitwise AND operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:132
func (x *Int64) CompareAndSwap(old int64, new int64) bool
CompareAndSwap executes the compare-and-swap operation for x.
sync/atomic/type.go:123
func (x *Int64) Load() int64
Load atomically loads and returns the value stored in x.
sync/atomic/type.go:114
func (x *Int64) Or(mask int64) int64
Or atomically performs a bitwise OR operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:136
func (x *Int64) Store(val int64)
Store atomically stores val into x.
sync/atomic/type.go:117
func (x *Int64) Swap(new int64) int64
Swap atomically stores new into x and returns the previous value.
sync/atomic/type.go:120
type Pointer[T any] struct {
// contains filtered or unexported fields
}A Pointer is an atomic pointer of type *T. The zero value is a nil *T. Pointer must not be copied after first use.
sync/atomic/type.go:47
func (x *interface{}) CompareAndSwap(old *T, new *T) boolCompareAndSwap executes the compare-and-swap operation for x.
sync/atomic/type.go:67
func (x *interface{}) Load() *TLoad atomically loads and returns the value stored in x.
sync/atomic/type.go:58
func (x *interface{}) Store(val *T)Store atomically stores val into x.
sync/atomic/type.go:61
func (x *interface{}) Swap(new *T) *TSwap atomically stores new into x and returns the previous value.
sync/atomic/type.go:64
type Uint32 struct {
// contains filtered or unexported fields
}A Uint32 is an atomic uint32. The zero value is zero. Uint32 must not be copied after first use.
sync/atomic/type.go:141
func (x *Uint32) Add(delta uint32) uint32
Add atomically adds delta to x and returns the new value.
sync/atomic/type.go:161
func (x *Uint32) And(mask uint32) uint32
And atomically performs a bitwise AND operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:165
func (x *Uint32) CompareAndSwap(old uint32, new uint32) bool
CompareAndSwap executes the compare-and-swap operation for x.
sync/atomic/type.go:156
func (x *Uint32) Load() uint32
Load atomically loads and returns the value stored in x.
sync/atomic/type.go:147
func (x *Uint32) Or(mask uint32) uint32
Or atomically performs a bitwise OR operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:169
func (x *Uint32) Store(val uint32)
Store atomically stores val into x.
sync/atomic/type.go:150
func (x *Uint32) Swap(new uint32) uint32
Swap atomically stores new into x and returns the previous value.
sync/atomic/type.go:153
type Uint64 struct {
// contains filtered or unexported fields
}A Uint64 is an atomic uint64. The zero value is zero. Uint64 must not be copied after first use.
sync/atomic/type.go:174
func (x *Uint64) Add(delta uint64) uint64
Add atomically adds delta to x and returns the new value.
sync/atomic/type.go:195
func (x *Uint64) And(mask uint64) uint64
And atomically performs a bitwise AND operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:199
func (x *Uint64) CompareAndSwap(old uint64, new uint64) bool
CompareAndSwap executes the compare-and-swap operation for x.
sync/atomic/type.go:190
func (x *Uint64) Load() uint64
Load atomically loads and returns the value stored in x.
sync/atomic/type.go:181
func (x *Uint64) Or(mask uint64) uint64
Or atomically performs a bitwise OR operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:203
func (x *Uint64) Store(val uint64)
Store atomically stores val into x.
sync/atomic/type.go:184
func (x *Uint64) Swap(new uint64) uint64
Swap atomically stores new into x and returns the previous value.
sync/atomic/type.go:187
type Uintptr struct {
// contains filtered or unexported fields
}A Uintptr is an atomic uintptr. The zero value is zero. Uintptr must not be copied after first use.
sync/atomic/type.go:208
func (x *Uintptr) Add(delta uintptr) uintptr
Add atomically adds delta to x and returns the new value.
sync/atomic/type.go:228
func (x *Uintptr) And(mask uintptr) uintptr
And atomically performs a bitwise AND operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:232
func (x *Uintptr) CompareAndSwap(old uintptr, new uintptr) bool
CompareAndSwap executes the compare-and-swap operation for x.
sync/atomic/type.go:223
func (x *Uintptr) Load() uintptr
Load atomically loads and returns the value stored in x.
sync/atomic/type.go:214
func (x *Uintptr) Or(mask uintptr) uintptr
Or atomically performs a bitwise OR operation on x using the bitmask provided as mask and returns the old value.
sync/atomic/type.go:236
func (x *Uintptr) Store(val uintptr)
Store atomically stores val into x.
sync/atomic/type.go:217
func (x *Uintptr) Swap(new uintptr) uintptr
Swap atomically stores new into x and returns the previous value.
sync/atomic/type.go:220
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 from [Value.Load]. Once [Value.Store] has been called, a Value must not be copied. A Value must not be copied after first use.
sync/atomic/value.go:16
func (v *Value) CompareAndSwap(old any, new any) bool
CompareAndSwap executes the compare-and-swap operation for the [Value]. All calls to CompareAndSwap for a given Value must use values of the same concrete type. CompareAndSwap of an inconsistent type panics, as does CompareAndSwap(old, nil).
sync/atomic/value.go:134
func (v *Value) Load() any
Load returns the value set by the most recent Store. It returns nil if there has been no call to Store for this Value.
sync/atomic/value.go:28
func (v *Value) Store(val any)
Store sets the value of the [Value] v to val. 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).
sync/atomic/value.go:47
func (v *Value) Swap(new any) any
Swap stores new into Value and returns the previous value. It returns nil if the Value is empty. All calls to Swap for a given Value must use values of the same concrete type. Swap of an inconsistent type panics, as does Swap(nil).
sync/atomic/value.go:90