atomics

Documentation

Overview

Package atomics provides types that can be concurrently accessed and modified, without caller code needing to implement locking.

Index

• Variables
• type Bool
  • func NewBool(value bool) Bool
  • func (b *Bool) Get() bool
  • func (b *Bool) Set(value bool)
  • func (b *Bool) Swap(value bool) bool
• type Once
  • func (o *Once) Do(f func()) bool
  • func (o *Once) Wait()
• type WaitGroup
  • func (wg *WaitGroup) Add(delta int) error
  • func (wg *WaitGroup) Done()
  • func (wg *WaitGroup) Drain()
  • func (wg *WaitGroup) Wait()
  • func (wg *WaitGroup) WaitAndDrain()

Variables

var ErrWaitGroupDraining = errors.New(
	"WaitGroup is draining, internal counter can no-longer be incremented",
)

ErrWaitGroupDraining is returned from WaitGroup.Add(), if WaitGroup is in draining state.

Types

type Bool

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

Bool is an atomic boolean, no need for locking which makes the code faster and simpler.

This interface is really just to abstract away the 0 or 1 value of an int32 modified using the sync/atomic package. Hopefully the go compiler will inline these methods so they'll be super fast.

func NewBool

func NewBool(value bool) Bool

NewBool returns an atomics.Bool initialized with value.

Note it is perfectly safe to just declare an atomics.Bool; it defaults to false just like a normal boolean would do.

func (*Bool) Get

func (b *Bool) Get() bool

Get returns the value of the boolean

func (*Bool) Set

func (b *Bool) Set(value bool)

Set sets the value of the boolean to true or false

func (*Bool) Swap

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

Swap sets the value of the boolean to true or false and returns the old value

type Once

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

Once is similar to sync.Done except that once.Do() returns true, if this was the first call to once.Do(). Additionally a method once.Wait() have been added for anyone waiting for this once.Do() to have been called.

Also once.Do(nil) will not panic, but act similar to once.Do(func(){}).

func (*Once) Do

func (o *Once) Do(f func()) bool

Do will call f() and return true, the first time once.Do() is called. All following callls to once.Do() will not call f() and return false.

func (*Once) Wait

func (o *Once) Wait()

Wait will block until once.Do() have been called once. After this once.Wait() will always return immediately.

type WaitGroup

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

WaitGroup is similar to sync.WaitGroup, except it can enter a draining state at which point additional calls to Add will fail and returns ErrWaitGroupDraining

func (*WaitGroup) Add

func (wg *WaitGroup) Add(delta int) error

Add will increment internal counter by delta, if not in draining state. If draining, Add(delta) return ErrWaitGroupDraining if delta is positive.

If the internal counter goes negative Add will panic.

func (*WaitGroup) Done

func (wg *WaitGroup) Done()

Done decrements internal counter and unblocks Wait() when it counter reaches zero.

If the internal counter goes negative Done will panic.

func (*WaitGroup) Drain

func (wg *WaitGroup) Drain()

Drain prevents additional increments using Add(delta)

func (*WaitGroup) Wait

func (wg *WaitGroup) Wait()

Wait blocks until internal counter reaches zero.

func (*WaitGroup) WaitAndDrain

func (wg *WaitGroup) WaitAndDrain()

WaitAndDrain will wait for the internal counter to reach zero and atomically switch to draining mode, so additional Add() calls will fail.