sync

Documentation

Overview

Package sync implements synchronization primitives similar to those provided by the standard Go implementation. These are not safe to access from within interrupts, or from another thread. The primitives also lack any fairness guarantees, similar to channels and the scheduler.

Index

• type Cond
  • func NewCond(l Locker) *Cond
  • func (c *Cond) Broadcast()
  • func (c *Cond) Signal()
  • func (c *Cond) Wait()
• type Locker
• type Map
  • func (m *Map) Delete(key interface{})
  • func (m *Map) Load(key interface{}) (value interface{}, ok bool)
  • func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)
  • func (m *Map) Range(f func(key, value interface{}) bool)
  • func (m *Map) Store(key, value interface{})
• type Mutex
  • func (m *Mutex) Lock()
  • func (m *Mutex) Unlock()
• type Once
  • func (o *Once) Do(f func())
• type Pool
  • func (p *Pool) Get() interface{}
  • func (p *Pool) Put(x interface{})
• type RWMutex
  • func (rw *RWMutex) Lock()
  • func (rw *RWMutex) RLock()
  • func (rw *RWMutex) RLocker() Locker
  • func (rw *RWMutex) RUnlock()
  • func (rw *RWMutex) Unlock()
• type WaitGroup
  • func (wg *WaitGroup) Add(delta int)
  • func (wg *WaitGroup) Done()
  • func (wg *WaitGroup) Wait()

Types

type Cond

type Cond struct {
	L Locker
	// contains filtered or unexported fields
}

func NewCond

func NewCond(l Locker) *Cond

func (*Cond) Broadcast

func (c *Cond) Broadcast()

func (*Cond) Signal

func (c *Cond) Signal()

func (*Cond) Wait

func (c *Cond) Wait()

type Locker

type Locker interface {
	Lock()
	Unlock()
}

type Map

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

func (*Map) Delete

func (m *Map) Delete(key interface{})

func (*Map) Load

func (m *Map) Load(key interface{}) (value interface{}, ok bool)

func (*Map) LoadOrStore

func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)

func (*Map) Range

func (m *Map) Range(f func(key, value interface{}) bool)

func (*Map) Store

func (m *Map) Store(key, value interface{})

type Mutex

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

func (*Mutex) Lock

func (m *Mutex) Lock()

func (*Mutex) Unlock

func (m *Mutex) Unlock()

type Once

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

func (*Once) Do

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

type Pool

type Pool struct {
	New func() interface{}
}

Pool is a very simple implementation of sync.Pool. It does not actually implement a pool.

func (*Pool) Get

func (p *Pool) Get() interface{}

Get returns the value of calling Pool.New().

func (*Pool) Put

func (p *Pool) Put(x interface{})

Put drops the value put into the pool.

type RWMutex

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

func (*RWMutex) Lock

func (rw *RWMutex) Lock()

func (*RWMutex) RLock

func (rw *RWMutex) RLock()

func (*RWMutex) RLocker

func (rw *RWMutex) RLocker() Locker

RLocker returns a Locker interface that implements the Lock and Unlock methods by calling rw.RLock and rw.RUnlock.

func (*RWMutex) RUnlock

func (rw *RWMutex) RUnlock()

func (*RWMutex) Unlock

func (rw *RWMutex) Unlock()

type WaitGroup

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

func (*WaitGroup) Add

func (wg *WaitGroup) Add(delta int)

func (*WaitGroup) Done

func (wg *WaitGroup) Done()

func (*WaitGroup) Wait

func (wg *WaitGroup) Wait()