Documentation
¶
Index ¶
- Variables
- func Once(fn func()) func()
- type AtomicBool
- type AtomicDuration
- type AtomicFloat64
- type Barrier
- type Cond
- type DoneChan
- type ImmutableResource
- type ImmutableResourceOption
- type Limit
- type LockedCalls
- type ManagedResource
- type OnceGuard
- type Pool
- type PoolOption
- type RefResource
- type ResourceManager
- type SharedCalls
- type SpinLock
- type TimeoutLimit
Constants ¶
This section is empty.
Variables ¶
View Source
var ErrLimitReturn = errors.New("discarding limited token, resource pool is full, someone returned multiple times")
ErrLimitReturn indicates that the more than borrowed elements were returned.
View Source
var ErrTimeout = errors.New("borrow timeout")
View Source
var ErrUseOfCleaned = errors.New("using a cleaned resource")
Functions ¶
Types ¶
type AtomicBool ¶
type AtomicBool uint32
func ForAtomicBool ¶
func ForAtomicBool(val bool) *AtomicBool
func NewAtomicBool ¶
func NewAtomicBool() *AtomicBool
func (*AtomicBool) CompareAndSwap ¶
func (b *AtomicBool) CompareAndSwap(old, val bool) bool
func (*AtomicBool) Set ¶
func (b *AtomicBool) Set(v bool)
func (*AtomicBool) True ¶
func (b *AtomicBool) True() bool
type AtomicDuration ¶
type AtomicDuration int64
func ForAtomicDuration ¶
func ForAtomicDuration(val time.Duration) *AtomicDuration
func NewAtomicDuration ¶
func NewAtomicDuration() *AtomicDuration
func (*AtomicDuration) CompareAndSwap ¶
func (d *AtomicDuration) CompareAndSwap(old, val time.Duration) bool
func (*AtomicDuration) Load ¶
func (d *AtomicDuration) Load() time.Duration
func (*AtomicDuration) Set ¶
func (d *AtomicDuration) Set(val time.Duration)
type AtomicFloat64 ¶
type AtomicFloat64 uint64
func ForAtomicFloat64 ¶
func ForAtomicFloat64(val float64) *AtomicFloat64
func NewAtomicFloat64 ¶
func NewAtomicFloat64() *AtomicFloat64
func (*AtomicFloat64) Add ¶
func (f *AtomicFloat64) Add(val float64) float64
func (*AtomicFloat64) CompareAndSwap ¶
func (f *AtomicFloat64) CompareAndSwap(old, val float64) bool
func (*AtomicFloat64) Load ¶
func (f *AtomicFloat64) Load() float64
func (*AtomicFloat64) Set ¶
func (f *AtomicFloat64) Set(val float64)
type Cond ¶
type Cond struct {
// contains filtered or unexported fields
}
type DoneChan ¶
type DoneChan struct {
// contains filtered or unexported fields
}
func NewDoneChan ¶
func NewDoneChan() *DoneChan
func (*DoneChan) Done ¶
func (dc *DoneChan) Done() chan lang.PlaceholderType
type ImmutableResource ¶
type ImmutableResource struct {
// contains filtered or unexported fields
}
func NewImmutableResource ¶
func NewImmutableResource(fn func() (interface{}, error), opts ...ImmutableResourceOption) *ImmutableResource
func (*ImmutableResource) Get ¶
func (ir *ImmutableResource) Get() (interface{}, error)
type ImmutableResourceOption ¶
type ImmutableResourceOption func(resource *ImmutableResource)
func WithRefreshIntervalOnFailure ¶
func WithRefreshIntervalOnFailure(interval time.Duration) ImmutableResourceOption
Set interval to 0 to enforce refresh every time if not succeeded. default is time.Second.
type Limit ¶
type Limit struct {
// contains filtered or unexported fields
}
Limit controls the concurrent requests.
func (Limit) Borrow ¶
func (l Limit) Borrow()
Borrow borrows an element from Limit in blocking mode.
type LockedCalls ¶
LockedCalls makes sure the calls with the same key to be called sequentially. For example, A called F, before it's done, B called F, then B's call would not blocked, after A's call finished, B's call got executed. The calls with the same key are independent, not sharing the returned values. A ------->calls F with key and executes<------->returns B ------------------>calls F with key<--------->executes<---->returns
func NewLockedCalls ¶
func NewLockedCalls() LockedCalls
type ManagedResource ¶
type ManagedResource struct {
// contains filtered or unexported fields
}
func NewManagedResource ¶
func NewManagedResource(generate func() interface{}, equals func(a, b interface{}) bool) *ManagedResource
func (*ManagedResource) MarkBroken ¶
func (mr *ManagedResource) MarkBroken(resource interface{})
func (*ManagedResource) Take ¶
func (mr *ManagedResource) Take() interface{}
type Pool ¶
type Pool struct {
// contains filtered or unexported fields
}
func NewPool ¶
func NewPool(n int, create func() interface{}, destroy func(interface{}), opts ...PoolOption) *Pool
type PoolOption ¶
type PoolOption func(*Pool)
func WithMaxAge ¶
func WithMaxAge(duration time.Duration) PoolOption
type RefResource ¶
type RefResource struct {
// contains filtered or unexported fields
}
func NewRefResource ¶
func NewRefResource(clean func()) *RefResource
func (*RefResource) Clean ¶
func (r *RefResource) Clean()
func (*RefResource) Use ¶
func (r *RefResource) Use() error
type ResourceManager ¶
type ResourceManager struct {
// contains filtered or unexported fields
}
func NewResourceManager ¶
func NewResourceManager() *ResourceManager
func (*ResourceManager) Close ¶
func (manager *ResourceManager) Close() error
func (*ResourceManager) GetResource ¶
type SharedCalls ¶
type SharedCalls interface {
}
SharedCalls lets the concurrent calls with the same key to share the call result. For example, A called F, before it's done, B called F. Then B would not execute F, and shared the result returned by F which called by A. The calls with the same key are dependent, concurrent calls share the returned values. A ------->calls F with key<------------------->returns val B --------------------->calls F with key------>returns val
func NewSharedCalls ¶
func NewSharedCalls() SharedCalls
type TimeoutLimit ¶
type TimeoutLimit struct {
// contains filtered or unexported fields
}
func NewTimeoutLimit ¶
func NewTimeoutLimit(n int) TimeoutLimit
func (TimeoutLimit) Return ¶
func (l TimeoutLimit) Return() error
func (TimeoutLimit) TryBorrow ¶
func (l TimeoutLimit) TryBorrow() bool
Source Files
Click to show internal directories.
Click to hide internal directories.