syncutil

Documentation

Overview

Package syncutil contains extensions and utilities for package sync from the standard library.

Index

• type ChanSemaphore
  • func NewChanSemaphore(maxRes uint) (c *ChanSemaphore)
  • func (c *ChanSemaphore) Acquire(ctx context.Context) (err error)
  • func (c *ChanSemaphore) Release()
• type EmptySemaphore
  • func (EmptySemaphore) Acquire(_ context.Context) (err error)
  • func (EmptySemaphore) Release()
• type OnceConstructor
  • func NewOnceConstructor[K comparable, V any](newFunc func(k K) (v V)) (c *OnceConstructor[K, V])
  • func (c *OnceConstructor[K, V]) Get(key K) (v V)
• type Pool
  • func NewPool[T any](newFunc func() (v *T)) (p *Pool[T])
  • func NewSlicePool[T any](l int) (p *Pool[[]T])
  • func (p *Pool[T]) Get() (v *T)
  • func (p *Pool[T]) Put(v *T)
• type Semaphore

Types

type ChanSemaphore

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

ChanSemaphore is a channel-based semaphore.

It must be initialized with NewChanSemaphore.

func NewChanSemaphore

func NewChanSemaphore(maxRes uint) (c *ChanSemaphore)

NewChanSemaphore returns a new *ChanSemaphore with the provided maximum resource number.

func (*ChanSemaphore) Acquire

func (c *ChanSemaphore) Acquire(ctx context.Context) (err error)

Acquire implements the Semaphore interface for *ChanSemaphore.

func (*ChanSemaphore) Release

func (c *ChanSemaphore) Release()

Release implements the Semaphore interface for *ChanSemaphore.

type EmptySemaphore

type EmptySemaphore struct{}

EmptySemaphore is a semaphore that has no limit.

func (EmptySemaphore) Acquire

func (EmptySemaphore) Acquire(_ context.Context) (err error)

Acquire implements the Semaphore interface for EmptySemaphore. It always returns nil.

func (EmptySemaphore) Release

func (EmptySemaphore) Release()

Release implements the Semaphore interface for EmptySemaphore.

type OnceConstructor

type OnceConstructor[K comparable, V any] struct {
	// contains filtered or unexported fields
}

OnceConstructor initializes a value for one key only once.

TODO(a.garipov): Add benchmarks.

func NewOnceConstructor

func NewOnceConstructor[K comparable, V any](newFunc func(k K) (v V)) (c *OnceConstructor[K, V])

NewOnceConstructor returns a new properly initialized *OnceConstructor that uses newFunc to construct a value for the given key.

func (*OnceConstructor[K, V]) Get

func (c *OnceConstructor[K, V]) Get(key K) (v V)

Get returns a value for the given key. If a value isn't available, it waits until it is.

type Pool

type Pool[T any] struct {
	// contains filtered or unexported fields
}

Pool is the strongly typed version of sync.Pool that manages pointers to T.

func NewPool

func NewPool[T any](newFunc func() (v *T)) (p *Pool[T])

NewPool returns a new strongly typed pool. newFunc must not be nil.

func NewSlicePool

func NewSlicePool[T any](l int) (p *Pool[[]T])

NewSlicePool is a helper for constructing pools with pointers to slices of a type with the given length.

func (*Pool[T]) Get

func (p *Pool[T]) Get() (v *T)

Get selects an arbitrary item from the pool, removes it from the pool, and returns it to the caller.

See sync.Pool.Get.

func (*Pool[T]) Put

func (p *Pool[T]) Put(v *T)

Put adds v to the pool.

See sync.Pool.Put.

type Semaphore

type Semaphore interface {
	// Acquire gets the resource, will block until the resource can be acquired.
	// ctx is used for cancellation.
	Acquire(ctx context.Context) (err error)

	// Release the resource, never blocks.
	Release()
}

Semaphore is the semaphore interface.