syncx

package
v1.4.3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 5, 2022 License: MIT Imports: 10 Imported by: 1

Documentation

Index

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")

ErrTimeout is an error that indicates the borrow timeout.

View Source
var ErrUseOfCleaned = errors.New("using a cleaned resource")

ErrUseOfCleaned is an error that indicates using a cleaned resource.

Functions

func Guard

func Guard(lock sync.Locker, fn func())

Guard guards the given fn with lock.

func Once

func Once(fn func()) func()

Once returns a func that guarantees fn can only called once.

Types

type AtomicBool

type AtomicBool uint32

An AtomicBool is an atomic implementation for boolean values.

func ForAtomicBool

func ForAtomicBool(val bool) *AtomicBool

ForAtomicBool returns an AtomicBool with given val.

func NewAtomicBool

func NewAtomicBool() *AtomicBool

NewAtomicBool returns an AtomicBool.

func (*AtomicBool) CompareAndSwap

func (b *AtomicBool) CompareAndSwap(old, val bool) bool

CompareAndSwap compares current value with given old, if equals, set to given val.

func (*AtomicBool) Set

func (b *AtomicBool) Set(v bool)

Set sets the value to v.

func (*AtomicBool) True

func (b *AtomicBool) True() bool

True returns true if current value is true.

type AtomicDuration

type AtomicDuration int64

An AtomicDuration is an implementation of atomic duration.

func ForAtomicDuration

func ForAtomicDuration(val time.Duration) *AtomicDuration

ForAtomicDuration returns an AtomicDuration with given value.

func NewAtomicDuration

func NewAtomicDuration() *AtomicDuration

NewAtomicDuration returns an AtomicDuration.

func (*AtomicDuration) CompareAndSwap

func (d *AtomicDuration) CompareAndSwap(old, val time.Duration) bool

CompareAndSwap compares current value with old, if equals, set the value to val.

func (*AtomicDuration) Load

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

Load loads the current duration.

func (*AtomicDuration) Set

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

Set sets the value to val.

type AtomicFloat64

type AtomicFloat64 uint64

An AtomicFloat64 is an implementation of atomic float64.

func ForAtomicFloat64

func ForAtomicFloat64(val float64) *AtomicFloat64

ForAtomicFloat64 returns an AtomicFloat64 with given val.

func NewAtomicFloat64

func NewAtomicFloat64() *AtomicFloat64

NewAtomicFloat64 returns an AtomicFloat64.

func (*AtomicFloat64) Add

func (f *AtomicFloat64) Add(val float64) float64

Add adds val to current value.

func (*AtomicFloat64) CompareAndSwap

func (f *AtomicFloat64) CompareAndSwap(old, val float64) bool

CompareAndSwap compares current value with old, if equals, set the value to val.

func (*AtomicFloat64) Load

func (f *AtomicFloat64) Load() float64

Load loads the current value.

func (*AtomicFloat64) Set

func (f *AtomicFloat64) Set(val float64)

Set sets the current value to val.

type Barrier

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

A Barrier is used to facility the barrier on a resource.

func (*Barrier) Guard

func (b *Barrier) Guard(fn func())

Guard guards the given fn on the resource.

type Cond

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

A Cond is used to wait for conditions.

func NewCond

func NewCond() *Cond

NewCond returns a Cond.

func (*Cond) Signal

func (cond *Cond) Signal()

Signal wakes one goroutine waiting on c, if there is any.

func (*Cond) Wait

func (cond *Cond) Wait()

Wait waits for signals.

func (*Cond) WaitWithTimeout

func (cond *Cond) WaitWithTimeout(timeout time.Duration) (time.Duration, bool)

WaitWithTimeout wait for signal return remain wait time or timed out.

type DoneChan

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

A DoneChan is used as a channel that can be closed multiple times and wait for done.

func NewDoneChan

func NewDoneChan() *DoneChan

NewDoneChan returns a DoneChan.

func (*DoneChan) Close

func (dc *DoneChan) Close()

Close closes dc, it's safe to close more than once.

func (*DoneChan) Done

func (dc *DoneChan) Done() chan lang.PlaceholderType

Done returns a channel that can be notified on dc closed.

type ImmutableResource

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

An ImmutableResource is used to manage an immutable resource.

func NewImmutableResource

func NewImmutableResource(fn func() (interface{}, error), opts ...ImmutableResourceOption) *ImmutableResource

NewImmutableResource returns an ImmutableResource.

func (*ImmutableResource) Get

func (ir *ImmutableResource) Get() (interface{}, error)

Get gets the immutable resource, fetches automatically if not loaded.

type ImmutableResourceOption

type ImmutableResourceOption func(resource *ImmutableResource)

ImmutableResourceOption defines the method to customize an ImmutableResource.

func WithRefreshIntervalOnFailure

func WithRefreshIntervalOnFailure(interval time.Duration) ImmutableResourceOption

WithRefreshIntervalOnFailure sets refresh interval on failure. 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 NewLimit

func NewLimit(n int) Limit

NewLimit creates a Limit that can borrow n elements from it concurrently.

func (Limit) Borrow

func (l Limit) Borrow()

Borrow borrows an element from Limit in blocking mode.

func (Limit) Return

func (l Limit) Return() error

Return returns the borrowed resource, returns error only if returned more than borrowed.

func (Limit) TryBorrow

func (l Limit) TryBorrow() bool

TryBorrow tries to borrow an element from Limit, in non-blocking mode. If success, true returned, false for otherwise.

type LockedCalls

type LockedCalls interface {
	Do(key string, fn func() (interface{}, error)) (interface{}, error)
}

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

NewLockedCalls returns a LockedCalls.

type ManagedResource

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

A ManagedResource is used to manage a resource that might be broken and refetched, like a connection.

func NewManagedResource

func NewManagedResource(generate func() interface{}, equals func(a, b interface{}) bool) *ManagedResource

NewManagedResource returns a ManagedResource.

func (*ManagedResource) MarkBroken

func (mr *ManagedResource) MarkBroken(resource interface{})

MarkBroken marks the resource broken.

func (*ManagedResource) Take

func (mr *ManagedResource) Take() interface{}

Take takes the resource, if not loaded, generates it.

type OnceGuard

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

An OnceGuard is used to make sure a resource can be taken once.

func (*OnceGuard) Take

func (og *OnceGuard) Take() bool

Take takes the resource, returns true on success, false for otherwise.

func (*OnceGuard) Taken

func (og *OnceGuard) Taken() bool

Taken checks if the resource is taken.

type Pool

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

A Pool is used to pool resources. The difference between sync.Pool is that:

  1. the limit of the resources
  2. max age of the resources can be set
  3. the method to destroy resources can be customized

func NewPool

func NewPool(n int, create func() interface{}, destroy func(interface{}), opts ...PoolOption) *Pool

NewPool returns a Pool.

func (*Pool) Get

func (p *Pool) Get() interface{}

Get gets a resource.

func (*Pool) Put

func (p *Pool) Put(x interface{})

Put puts a resource back.

type PoolOption

type PoolOption func(*Pool)

PoolOption defines the method to customize a Pool.

func WithMaxAge

func WithMaxAge(duration time.Duration) PoolOption

WithMaxAge returns a function to customize a Pool with given max age.

type RefResource

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

A RefResource is used to reference counting a resource.

func NewRefResource

func NewRefResource(clean func()) *RefResource

NewRefResource returns a RefResource.

func (*RefResource) Clean

func (r *RefResource) Clean()

Clean cleans a resource with reference count decremented.

func (*RefResource) Use

func (r *RefResource) Use() error

Use uses the resource with reference count incremented.

type ResourceManager

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

A ResourceManager is a manager that used to manage resources.

func NewResourceManager

func NewResourceManager() *ResourceManager

NewResourceManager returns a ResourceManager.

func (*ResourceManager) Close

func (manager *ResourceManager) Close() error

Close closes the manager. Don't use the ResourceManager after Close() called.

func (*ResourceManager) GetResource

func (manager *ResourceManager) GetResource(key string, create func() (io.Closer, error)) (io.Closer, error)

GetResource returns the resource associated with given key.

func (*ResourceManager) Inject

func (manager *ResourceManager) Inject(key string, resource io.Closer)

Inject injects the resource associated with given key.

type SingleFlight

type SingleFlight interface {
	Do(key string, fn func() (interface{}, error)) (interface{}, error)
	DoEx(key string, fn func() (interface{}, error)) (interface{}, bool, error)
}

SingleFlight 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 NewSingleFlight

func NewSingleFlight() SingleFlight

NewSingleFlight returns a SingleFlight.

type SpinLock

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

A SpinLock is used as a lock a fast execution.

func (*SpinLock) Lock

func (sl *SpinLock) Lock()

Lock locks the SpinLock.

func (*SpinLock) TryLock

func (sl *SpinLock) TryLock() bool

TryLock tries to lock the SpinLock.

func (*SpinLock) Unlock

func (sl *SpinLock) Unlock()

Unlock unlocks the SpinLock.

type TimeoutLimit

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

A TimeoutLimit is used to borrow with timeouts.

func NewTimeoutLimit

func NewTimeoutLimit(n int) TimeoutLimit

NewTimeoutLimit returns a TimeoutLimit.

func (TimeoutLimit) Borrow

func (l TimeoutLimit) Borrow(timeout time.Duration) error

Borrow borrows with given timeout.

func (TimeoutLimit) Return

func (l TimeoutLimit) Return() error

Return returns a borrow.

func (TimeoutLimit) TryBorrow

func (l TimeoutLimit) TryBorrow() bool

TryBorrow tries a borrow.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL