syncs

Documentation

Overview

Package syncs contains additional sync types and functionality.

Index

• func AssertLocked(m *sync.Mutex)
• func AssertRLocked(rw *sync.RWMutex)
• func AssertWLocked(rw *sync.RWMutex)
• func ClosedChan() <-chan struct{}
• func Watch(ctx context.Context, mu sync.Locker, tick, max time.Duration) chan time.Duration
• type AtomicBool
  • func (b *AtomicBool) Get() bool
  • func (b *AtomicBool) Set(v bool)
  • func (b *AtomicBool) Swap(v bool) (changed bool)
• type AtomicUint32
  • func (b *AtomicUint32) Get() uint32
  • func (b *AtomicUint32) Set(v uint32)
• type Semaphore
  • func NewSemaphore(n int) Semaphore
  • func (s Semaphore) Acquire()
  • func (s Semaphore) AcquireContext(ctx context.Context) bool
  • func (s Semaphore) Release()
  • func (s Semaphore) TryAcquire() bool
• type WaitGroupChan
  • func NewWaitGroupChan() *WaitGroupChan
  • func (wg *WaitGroupChan) Add(delta int)
  • func (wg *WaitGroupChan) Decr()
  • func (wg *WaitGroupChan) DoneChan() <-chan struct{}
  • func (wg *WaitGroupChan) Wait()

Functions

func AssertLocked

func AssertLocked(m *sync.Mutex)

AssertLocked panics if m is not locked.

func AssertRLocked

func AssertRLocked(rw *sync.RWMutex)

AssertRLocked panics if rw is not locked for reading or writing.

func AssertWLocked

func AssertWLocked(rw *sync.RWMutex)

AssertWLocked panics if rw is not locked for writing.

func ClosedChan

func ClosedChan() <-chan struct{}

ClosedChan returns a channel that's already closed.

func Watch

func Watch(ctx context.Context, mu sync.Locker, tick, max time.Duration) chan time.Duration

Watch monitors mu for contention. On first call, and at every tick, Watch locks and unlocks mu. (Tick should be large to avoid adding contention to mu.) Max is the maximum length of time Watch will wait to acquire the lock. The time required to lock mu is sent on the returned channel. Watch exits when ctx is done, and closes the returned channel.

Types

type AtomicBool

type AtomicBool int32

AtomicBool is an atomic boolean.

func (*AtomicBool) Get

func (b *AtomicBool) Get() bool

func (*AtomicBool) Set

func (b *AtomicBool) Set(v bool)

func (*AtomicBool) Swap

func (b *AtomicBool) Swap(v bool) (changed bool)

Swap sets b to v and reports whether it changed.

type AtomicUint32

type AtomicUint32 uint32

AtomicUint32 is an atomic uint32.

func (*AtomicUint32) Get

func (b *AtomicUint32) Get() uint32

func (*AtomicUint32) Set

func (b *AtomicUint32) Set(v uint32)

type Semaphore

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

Semaphore is a counting semaphore.

Use NewSemaphore to create one.

func NewSemaphore

func NewSemaphore(n int) Semaphore

NewSemaphore returns a semaphore with resource count n.

func (Semaphore) Acquire

func (s Semaphore) Acquire()

Acquire blocks until a resource is acquired.

func (Semaphore) AcquireContext

func (s Semaphore) AcquireContext(ctx context.Context) bool

AcquireContext reports whether the resource was acquired before the ctx was done.

func (Semaphore) Release

func (s Semaphore) Release()

Release releases a resource.

func (Semaphore) TryAcquire

func (s Semaphore) TryAcquire() bool

TryAcquire reports, without blocking, whether the resource was acquired.

type WaitGroupChan

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

WaitGroupChan is like a sync.WaitGroup, but has a chan that closes on completion that you can wait on. (This, you can only use the value once) Also, its zero value is not usable. Use the constructor.

func NewWaitGroupChan

func NewWaitGroupChan() *WaitGroupChan

NewWaitGroupChan returns a new single-use WaitGroupChan.

func (*WaitGroupChan) Add

func (wg *WaitGroupChan) Add(delta int)

Add adds delta, which may be negative, to the WaitGroupChan counter. If the counter becomes zero, all goroutines blocked on Wait or the Done chan are released. If the counter goes negative, Add panics.

Note that calls with a positive delta that occur when the counter is zero must happen before a Wait. Calls with a negative delta, or calls with a positive delta that start when the counter is greater than zero, may happen at any time. Typically this means the calls to Add should execute before the statement creating the goroutine or other event to be waited for.

func (*WaitGroupChan) Decr

func (wg *WaitGroupChan) Decr()

Decr decrements the WaitGroup counter by one.

(It is like sync.WaitGroup's Done method, but we don't use Done in this type, because it's ambiguous between Context.Done and WaitGroup.Done. So we use DoneChan and Decr instead.)

func (*WaitGroupChan) DoneChan

func (wg *WaitGroupChan) DoneChan() <-chan struct{}

DoneChan returns a channel that's closed on completion.

func (*WaitGroupChan) Wait

func (wg *WaitGroupChan) Wait()

Wait blocks until the WaitGroupChan counter is zero.