sync

Documentation

Index

• Variables
• type CappedPool
  • func InitCappedPool[V any](p *CappedPool[V], cap int) *CappedPool[V]
  • func NewCappedPool[V any](cap int) *CappedPool[V]
  • func (p *CappedPool[V]) Close()
  • func (p *CappedPool[V]) Get(ctx context.Context) (v V, err error)
  • func (p *CappedPool[V]) Put(v V) error
• type ConcurrencyPool
  • func InitConcurrencyPool[V any](p *CappedPool[V], cap int) *ConcurrencyPool[V]
  • func NewConcurrencyPool[V any](cap int) *ConcurrencyPool[V]
  • func (p *ConcurrencyPool[V]) Get(ctx context.Context) (v V, err error)
  • func (p *ConcurrencyPool[V]) Put(v V) error
  • func (p *ConcurrencyPool[V]) Release(v V)
• type NilPool
  • func (p *NilPool[V]) Close()
  • func (p *NilPool[V]) Get(_ context.Context) (v V, err error)
  • func (p *NilPool[V]) Put(v V) error
  • func (p *NilPool[V]) Release(v V)
• type Pool
• type WaitGroup
  • func (wg *WaitGroup) Add(delta int)
  • func (wg *WaitGroup) Done()
  • func (wg *WaitGroup) IsWaiting() bool
  • func (wg *WaitGroup) Reset()
• type WaitPool

Variables

var (
	ErrPoolClosed = errors.New("pool is closed")
	ErrPoolFull   = errors.New("pool is full")
)

Types

type CappedPool

type CappedPool[V any] struct {
	New    func() V
	Closer func(V)
	// contains filtered or unexported fields
}

CappedPool is a pool that will pool a limited number of values

func InitCappedPool

func InitCappedPool[V any](p *CappedPool[V], cap int) *CappedPool[V]

func NewCappedPool

func NewCappedPool[V any](cap int) *CappedPool[V]

func (*CappedPool[V]) Close

func (p *CappedPool[V]) Close()

func (*CappedPool[V]) Get

func (p *CappedPool[V]) Get(ctx context.Context) (v V, err error)

func (*CappedPool[V]) Put

func (p *CappedPool[V]) Put(v V) error

type ConcurrencyPool

type ConcurrencyPool[V any] struct {
	*CappedPool[V]

	// The minimum duration the Get can be blocked. The default is one second.
	BlockInterval time.Duration
	// contains filtered or unexported fields
}

func InitConcurrencyPool

func InitConcurrencyPool[V any](p *CappedPool[V], cap int) *ConcurrencyPool[V]

func NewConcurrencyPool

func NewConcurrencyPool[V any](cap int) *ConcurrencyPool[V]

func (*ConcurrencyPool[V]) Get

func (p *ConcurrencyPool[V]) Get(ctx context.Context) (v V, err error)

func (*ConcurrencyPool[V]) Put

func (p *ConcurrencyPool[V]) Put(v V) error

func (*ConcurrencyPool[V]) Release

func (p *ConcurrencyPool[V]) Release(v V)

type NilPool

type NilPool[V any] struct {
	New    func() V
	Closer func(V)
}

func (*NilPool[V]) Close

func (p *NilPool[V]) Close()

func (*NilPool[V]) Get

func (p *NilPool[V]) Get(_ context.Context) (v V, err error)

func (*NilPool[V]) Put

func (p *NilPool[V]) Put(v V) error

func (*NilPool[V]) Release

func (p *NilPool[V]) Release(v V)

type Pool

type Pool[V any] interface {
	// Get returns a value qualifies specified filter from the pool.
	Get(context.Context) (V, error)

	// Put puts a function back to the pool.
	Put(V) error

	// Close closes the pool.
	Close()
}

Pool defines a pool that supports eviction awareness and get value by specified filters.

type WaitGroup

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

func (*WaitGroup) Add

func (wg *WaitGroup) Add(delta int)

func (*WaitGroup) Done

func (wg *WaitGroup) Done()

func (*WaitGroup) IsWaiting

func (wg *WaitGroup) IsWaiting() bool

func (*WaitGroup) Reset

func (wg *WaitGroup) Reset()

type WaitPool

type WaitPool[V any] interface {
	Pool[V]

	// Release releases the quota occupied by a pooling value.
	Release(V)
}

WaitPool defines a pool that has limited capacity and will wait for a value to be returned if the pool is full.