README

atomic GoDoc Build Status Coverage Status Go Report Card

Simple wrappers for primitive types to enforce atomic access.

Installation

go get -u go.uber.org/atomic

Usage

The standard library's sync/atomic is powerful, but it's easy to forget which variables must be accessed atomically. go.uber.org/atomic preserves all the functionality of the standard library, but wraps the primitive types to provide a safer, more convenient API.

var atom atomic.Uint32
atom.Store(42)
atom.Sub(2)
atom.CAS(40, 11)

See the documentation for a complete API specification.

Development Status

Stable.


Released under the [MIT License](LICENSE.txt).

Documentation

Overview

    Package atomic provides simple wrappers around numerics to enforce atomic access.

    Example
    Output:
    
    43
    true
    0
    

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Bool

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

      Bool is an atomic Boolean.

      func NewBool

      func NewBool(initial bool) *Bool

        NewBool creates a Bool.

        func (*Bool) CAS

        func (b *Bool) CAS(old, new bool) bool

          CAS is an atomic compare-and-swap.

          func (*Bool) Load

          func (b *Bool) Load() bool

            Load atomically loads the Boolean.

            func (*Bool) Store

            func (b *Bool) Store(new bool)

              Store atomically stores the passed value.

              func (*Bool) Swap

              func (b *Bool) Swap(new bool) bool

                Swap sets the given value and returns the previous value.

                func (*Bool) Toggle

                func (b *Bool) Toggle() bool

                  Toggle atomically negates the Boolean and returns the previous value.

                  type Duration

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

                    Duration is an atomic wrapper around time.Duration https://godoc.org/time#Duration

                    func NewDuration

                    func NewDuration(d time.Duration) *Duration

                      NewDuration creates a Duration.

                      func (*Duration) Add

                      func (d *Duration) Add(n time.Duration) time.Duration

                        Add atomically adds to the wrapped time.Duration and returns the new value.

                        func (*Duration) CAS

                        func (d *Duration) CAS(old, new time.Duration) bool

                          CAS is an atomic compare-and-swap.

                          func (*Duration) Load

                          func (d *Duration) Load() time.Duration

                            Load atomically loads the wrapped value.

                            func (*Duration) Store

                            func (d *Duration) Store(n time.Duration)

                              Store atomically stores the passed value.

                              func (*Duration) Sub

                              func (d *Duration) Sub(n time.Duration) time.Duration

                                Sub atomically subtracts from the wrapped time.Duration and returns the new value.

                                func (*Duration) Swap

                                func (d *Duration) Swap(n time.Duration) time.Duration

                                  Swap atomically swaps the wrapped time.Duration and returns the old value.

                                  type Float64

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

                                    Float64 is an atomic wrapper around float64.

                                    func NewFloat64

                                    func NewFloat64(f float64) *Float64

                                      NewFloat64 creates a Float64.

                                      func (*Float64) Add

                                      func (f *Float64) Add(s float64) float64

                                        Add atomically adds to the wrapped float64 and returns the new value.

                                        func (*Float64) CAS

                                        func (f *Float64) CAS(old, new float64) bool

                                          CAS is an atomic compare-and-swap.

                                          func (*Float64) Load

                                          func (f *Float64) Load() float64

                                            Load atomically loads the wrapped value.

                                            func (*Float64) Store

                                            func (f *Float64) Store(s float64)

                                              Store atomically stores the passed value.

                                              func (*Float64) Sub

                                              func (f *Float64) Sub(s float64) float64

                                                Sub atomically subtracts from the wrapped float64 and returns the new value.

                                                type Int32

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

                                                  Int32 is an atomic wrapper around an int32.

                                                  func NewInt32

                                                  func NewInt32(i int32) *Int32

                                                    NewInt32 creates an Int32.

                                                    func (*Int32) Add

                                                    func (i *Int32) Add(n int32) int32

                                                      Add atomically adds to the wrapped int32 and returns the new value.

                                                      func (*Int32) CAS

                                                      func (i *Int32) CAS(old, new int32) bool

                                                        CAS is an atomic compare-and-swap.

                                                        func (*Int32) Dec

                                                        func (i *Int32) Dec() int32

                                                          Dec atomically decrements the wrapped int32 and returns the new value.

                                                          func (*Int32) Inc

                                                          func (i *Int32) Inc() int32

                                                            Inc atomically increments the wrapped int32 and returns the new value.

                                                            func (*Int32) Load

                                                            func (i *Int32) Load() int32

                                                              Load atomically loads the wrapped value.

                                                              func (*Int32) Store

                                                              func (i *Int32) Store(n int32)

                                                                Store atomically stores the passed value.

                                                                func (*Int32) Sub

                                                                func (i *Int32) Sub(n int32) int32

                                                                  Sub atomically subtracts from the wrapped int32 and returns the new value.

                                                                  func (*Int32) Swap

                                                                  func (i *Int32) Swap(n int32) int32

                                                                    Swap atomically swaps the wrapped int32 and returns the old value.

                                                                    type Int64

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

                                                                      Int64 is an atomic wrapper around an int64.

                                                                      func NewInt64

                                                                      func NewInt64(i int64) *Int64

                                                                        NewInt64 creates an Int64.

                                                                        func (*Int64) Add

                                                                        func (i *Int64) Add(n int64) int64

                                                                          Add atomically adds to the wrapped int64 and returns the new value.

                                                                          func (*Int64) CAS

                                                                          func (i *Int64) CAS(old, new int64) bool

                                                                            CAS is an atomic compare-and-swap.

                                                                            func (*Int64) Dec

                                                                            func (i *Int64) Dec() int64

                                                                              Dec atomically decrements the wrapped int64 and returns the new value.

                                                                              func (*Int64) Inc

                                                                              func (i *Int64) Inc() int64

                                                                                Inc atomically increments the wrapped int64 and returns the new value.

                                                                                func (*Int64) Load

                                                                                func (i *Int64) Load() int64

                                                                                  Load atomically loads the wrapped value.

                                                                                  func (*Int64) Store

                                                                                  func (i *Int64) Store(n int64)

                                                                                    Store atomically stores the passed value.

                                                                                    func (*Int64) Sub

                                                                                    func (i *Int64) Sub(n int64) int64

                                                                                      Sub atomically subtracts from the wrapped int64 and returns the new value.

                                                                                      func (*Int64) Swap

                                                                                      func (i *Int64) Swap(n int64) int64

                                                                                        Swap atomically swaps the wrapped int64 and returns the old value.

                                                                                        type String

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

                                                                                          String is an atomic type-safe wrapper around Value for strings.

                                                                                          func NewString

                                                                                          func NewString(str string) *String

                                                                                            NewString creates a String.

                                                                                            func (*String) Load

                                                                                            func (s *String) Load() string

                                                                                              Load atomically loads the wrapped string.

                                                                                              func (*String) Store

                                                                                              func (s *String) Store(str string)

                                                                                                Store atomically stores the passed string. Note: Converting the string to an interface{} to store in the Value requires an allocation.

                                                                                                type Uint32

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

                                                                                                  Uint32 is an atomic wrapper around an uint32.

                                                                                                  func NewUint32

                                                                                                  func NewUint32(i uint32) *Uint32

                                                                                                    NewUint32 creates a Uint32.

                                                                                                    func (*Uint32) Add

                                                                                                    func (i *Uint32) Add(n uint32) uint32

                                                                                                      Add atomically adds to the wrapped uint32 and returns the new value.

                                                                                                      func (*Uint32) CAS

                                                                                                      func (i *Uint32) CAS(old, new uint32) bool

                                                                                                        CAS is an atomic compare-and-swap.

                                                                                                        func (*Uint32) Dec

                                                                                                        func (i *Uint32) Dec() uint32

                                                                                                          Dec atomically decrements the wrapped int32 and returns the new value.

                                                                                                          func (*Uint32) Inc

                                                                                                          func (i *Uint32) Inc() uint32

                                                                                                            Inc atomically increments the wrapped uint32 and returns the new value.

                                                                                                            func (*Uint32) Load

                                                                                                            func (i *Uint32) Load() uint32

                                                                                                              Load atomically loads the wrapped value.

                                                                                                              func (*Uint32) Store

                                                                                                              func (i *Uint32) Store(n uint32)

                                                                                                                Store atomically stores the passed value.

                                                                                                                func (*Uint32) Sub

                                                                                                                func (i *Uint32) Sub(n uint32) uint32

                                                                                                                  Sub atomically subtracts from the wrapped uint32 and returns the new value.

                                                                                                                  func (*Uint32) Swap

                                                                                                                  func (i *Uint32) Swap(n uint32) uint32

                                                                                                                    Swap atomically swaps the wrapped uint32 and returns the old value.

                                                                                                                    type Uint64

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

                                                                                                                      Uint64 is an atomic wrapper around a uint64.

                                                                                                                      func NewUint64

                                                                                                                      func NewUint64(i uint64) *Uint64

                                                                                                                        NewUint64 creates a Uint64.

                                                                                                                        func (*Uint64) Add

                                                                                                                        func (i *Uint64) Add(n uint64) uint64

                                                                                                                          Add atomically adds to the wrapped uint64 and returns the new value.

                                                                                                                          func (*Uint64) CAS

                                                                                                                          func (i *Uint64) CAS(old, new uint64) bool

                                                                                                                            CAS is an atomic compare-and-swap.

                                                                                                                            func (*Uint64) Dec

                                                                                                                            func (i *Uint64) Dec() uint64

                                                                                                                              Dec atomically decrements the wrapped uint64 and returns the new value.

                                                                                                                              func (*Uint64) Inc

                                                                                                                              func (i *Uint64) Inc() uint64

                                                                                                                                Inc atomically increments the wrapped uint64 and returns the new value.

                                                                                                                                func (*Uint64) Load

                                                                                                                                func (i *Uint64) Load() uint64

                                                                                                                                  Load atomically loads the wrapped value.

                                                                                                                                  func (*Uint64) Store

                                                                                                                                  func (i *Uint64) Store(n uint64)

                                                                                                                                    Store atomically stores the passed value.

                                                                                                                                    func (*Uint64) Sub

                                                                                                                                    func (i *Uint64) Sub(n uint64) uint64

                                                                                                                                      Sub atomically subtracts from the wrapped uint64 and returns the new value.

                                                                                                                                      func (*Uint64) Swap

                                                                                                                                      func (i *Uint64) Swap(n uint64) uint64

                                                                                                                                        Swap atomically swaps the wrapped uint64 and returns the old value.

                                                                                                                                        type Value

                                                                                                                                        type Value struct{ atomic.Value }

                                                                                                                                          Value shadows the type of the same name from sync/atomic https://godoc.org/sync/atomic#Value