sync2

Documentation

Index

• type AtomicDuration
  • func (d *AtomicDuration) Add(duration time.Duration) time.Duration
  • func (d *AtomicDuration) CompareAndSwap(oldval, newval time.Duration) (swapped bool)
  • func (d *AtomicDuration) Get() time.Duration
  • func (d *AtomicDuration) Set(duration time.Duration)
• type AtomicInt32
  • func (i *AtomicInt32) Add(n int32) int32
  • func (i *AtomicInt32) CompareAndSwap(oldval, newval int32) (swapped bool)
  • func (i *AtomicInt32) Get() int32
  • func (i *AtomicInt32) Set(n int32)
• type AtomicInt64
  • func (i *AtomicInt64) Add(n int64) int64
  • func (i *AtomicInt64) CompareAndSwap(oldval, newval int64) (swapped bool)
  • func (i *AtomicInt64) Get() int64
  • func (i *AtomicInt64) Set(n int64)
• type AtomicString
  • func (s *AtomicString) CompareAndSwap(oldval, newval string) (swqpped bool)
  • func (s *AtomicString) Get() string
  • func (s *AtomicString) Set(str string)
• type AtomicUint32
  • func (i *AtomicUint32) Add(n uint32) uint32
  • func (i *AtomicUint32) CompareAndSwap(oldval, newval uint32) (swapped bool)
  • func (i *AtomicUint32) Get() uint32
  • func (i *AtomicUint32) Set(n uint32)
• type Cond
  • func NewCond(l sync.Locker) *Cond
  • func (c *Cond) Broadcast()
  • func (c *Cond) Signal()
  • func (c *Cond) Wait()
• type Semaphore
  • func NewSemaphore(count int, timeout time.Duration) *Semaphore
  • func (sem *Semaphore) Acquire() bool
  • func (sem *Semaphore) Release()

Types

type AtomicDuration

type AtomicDuration int64

func (*AtomicDuration) Add

func (d *AtomicDuration) Add(duration time.Duration) time.Duration

func (*AtomicDuration) CompareAndSwap

func (d *AtomicDuration) CompareAndSwap(oldval, newval time.Duration) (swapped bool)

func (*AtomicDuration) Get

func (d *AtomicDuration) Get() time.Duration

func (*AtomicDuration) Set

func (d *AtomicDuration) Set(duration time.Duration)

type AtomicInt32

type AtomicInt32 int32

func (*AtomicInt32) Add

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

func (*AtomicInt32) CompareAndSwap

func (i *AtomicInt32) CompareAndSwap(oldval, newval int32) (swapped bool)

func (*AtomicInt32) Get

func (i *AtomicInt32) Get() int32

func (*AtomicInt32) Set

func (i *AtomicInt32) Set(n int32)

type AtomicInt64

type AtomicInt64 int64

func (*AtomicInt64) Add

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

func (*AtomicInt64) CompareAndSwap

func (i *AtomicInt64) CompareAndSwap(oldval, newval int64) (swapped bool)

func (*AtomicInt64) Get

func (i *AtomicInt64) Get() int64

func (*AtomicInt64) Set

func (i *AtomicInt64) Set(n int64)

type AtomicString

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

AtomicString gives you atomic-style APIs for string, but it's only a convenience wrapper that uses a mutex. So, it's not as efficient as the rest of the atomic types.

func (*AtomicString) CompareAndSwap

func (s *AtomicString) CompareAndSwap(oldval, newval string) (swqpped bool)

func (*AtomicString) Get

func (s *AtomicString) Get() string

func (*AtomicString) Set

func (s *AtomicString) Set(str string)

type AtomicUint32

type AtomicUint32 uint32

func (*AtomicUint32) Add

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

func (*AtomicUint32) CompareAndSwap

func (i *AtomicUint32) CompareAndSwap(oldval, newval uint32) (swapped bool)

func (*AtomicUint32) Get

func (i *AtomicUint32) Get() uint32

func (*AtomicUint32) Set

func (i *AtomicUint32) Set(n uint32)

type Cond

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

Cond is an alternate implementation of sync.Cond

func NewCond

func NewCond(l sync.Locker) *Cond

func (*Cond) Broadcast

func (c *Cond) Broadcast()

func (*Cond) Signal

func (c *Cond) Signal()

func (*Cond) Wait

func (c *Cond) Wait()

type Semaphore

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

Semaphore is a counting semaphore with the option to specify a timeout.

func NewSemaphore

func NewSemaphore(count int, timeout time.Duration) *Semaphore

NewSemaphore creates a Semaphore. The count parameter must be a positive number. A timeout of zero means that there is no timeout.

func (*Semaphore) Acquire

func (sem *Semaphore) Acquire() bool

Acquire returns true on successful acquisition, and false on a timeout.

func (*Semaphore) Release

func (sem *Semaphore) Release()

Release releases the acquired semaphore. You must not release more than the number of semaphores you've acquired.