async

Sep 7, 2024

Changes in this version

+ var ErrExecutorQueueFull = errors.New("async: executor queue is full")

+ var ErrExecutorShutDown = errors.New("async: executor is shut down")

+ type Executor struct

+ func NewExecutor[T any](ctx context.Context, config *ExecutorConfig) *Executor[T]

+ func (e *Executor[T]) Shutdown() error

+ func (e *Executor[T]) Status() ExecutorStatus

+ func (e *Executor[T]) Submit(f func(context.Context) (T, error)) (Future[T], error)

+ type ExecutorConfig struct

+ QueueSize int

+ WorkerPoolSize int

+ func NewExecutorConfig(workerPoolSize, queueSize int) *ExecutorConfig

+ type ExecutorService interface

+ Shutdown func() error

+ Status func() ExecutorStatus

+ Submit func(func(context.Context) (T, error)) (Future[T], error)

+ type ExecutorStatus uint32

+ const ExecutorStatusRunning

+ const ExecutorStatusShutDown

+ const ExecutorStatusTerminating

+ type PriorityLock struct

+ func NewPriorityLock(maxPriority int) *PriorityLock

+ func (pl *PriorityLock) Lock()

+ func (pl *PriorityLock) LockP(priority int)

+ func (pl *PriorityLock) Unlock()

Feb 16, 2024

Changes in this version

+ type ShardedMap struct

+ func NewShardedMapWithHash[K comparable, V any](shards int, hashFunc func(K) uint64) *ShardedMap[K, V]

+ func NewShardedMap[K comparable, V any](shards int) *ShardedMap[K, V]

+ func (sm *ShardedMap[K, V]) Clear()

+ func (sm *ShardedMap[K, V]) ComputeIfAbsent(key K, mappingFunction func(K) *V) *V

+ func (sm *ShardedMap[K, V]) ContainsKey(key K) bool

+ func (sm *ShardedMap[K, V]) Get(key K) *V

+ func (sm *ShardedMap[K, V]) GetOrDefault(key K, defaultValue *V) *V

+ func (sm *ShardedMap[K, V]) IsEmpty() bool

+ func (sm *ShardedMap[K, V]) KeySet() []K

+ func (sm *ShardedMap[K, V]) Put(key K, value *V)

+ func (sm *ShardedMap[K, V]) Remove(key K) *V

+ func (sm *ShardedMap[K, V]) Size() int

+ func (sm *ShardedMap[K, V]) Values() []*V

+ type SynchronizedMap struct

+ func NewSynchronizedMap[K comparable, V any]() *SynchronizedMap[K, V]

+ func (sync *SynchronizedMap[K, V]) Clear()

+ func (sync *SynchronizedMap[K, V]) ComputeIfAbsent(key K, mappingFunction func(K) *V) *V

+ func (sync *SynchronizedMap[K, V]) ContainsKey(key K) bool

+ func (sync *SynchronizedMap[K, V]) Get(key K) *V

+ func (sync *SynchronizedMap[K, V]) GetOrDefault(key K, defaultValue *V) *V

+ func (sync *SynchronizedMap[K, V]) IsEmpty() bool

+ func (sync *SynchronizedMap[K, V]) KeySet() []K

+ func (sync *SynchronizedMap[K, V]) Put(key K, value *V)

+ func (sync *SynchronizedMap[K, V]) Remove(key K) *V

+ func (sync *SynchronizedMap[K, V]) Size() int

+ func (sync *SynchronizedMap[K, V]) Values() []*V

Nov 11, 2023

Changes in this version

+ type Value struct

+ func (v *Value) CompareAndSwap(old any, new any) (swapped bool)

+ func (v *Value) Load() (val any)

+ func (v *Value) Store(val any)

+ func (v *Value) Swap(new any) (old any)

Oct 14, 2023

Changes in this version

+ type ConcurrentMap struct

+ func NewConcurrentMap() *ConcurrentMap[K, V]

+ func (cm *ConcurrentMap[K, V]) Clear()

+ func (cm *ConcurrentMap[K, V]) ComputeIfAbsent(key K, mappingFunction func(K) *V) *V

+ func (cm *ConcurrentMap[K, V]) ContainsKey(key K) bool

+ func (cm *ConcurrentMap[K, V]) Get(key K) *V

+ func (cm *ConcurrentMap[K, V]) GetOrDefault(key K, defaultValue *V) *V

+ func (cm *ConcurrentMap[K, V]) IsEmpty() bool

+ func (cm *ConcurrentMap[K, V]) KeySet() []K

+ func (cm *ConcurrentMap[K, V]) Put(key K, value *V)

+ func (cm *ConcurrentMap[K, V]) Remove(key K) *V

+ func (cm *ConcurrentMap[K, V]) Size() int

+ func (cm *ConcurrentMap[K, V]) Values() []*V

+ type Map interface

+ Clear func()

+ ComputeIfAbsent func(key K, mappingFunction func(K) *V) *V

+ ContainsKey func(key K) bool

+ Get func(key K) *V

+ GetOrDefault func(key K, defaultValue *V) *V

+ IsEmpty func() bool

+ KeySet func() []K

+ Put func(key K, value *V)

+ Remove func(key K) *V

+ Size func() int

+ Values func() []*V

+ type Once struct

+ func (o *Once[T]) Do(f func() (T, error)) (T, error)

Nov 26, 2022

Changes in this version

type Future

+ Join func() (T, error)

type FutureImpl

+ func (fut *FutureImpl[T]) Join() (T, error)

+ type WaitGroupContext struct

+ func NewWaitGroupContext(ctx context.Context) *WaitGroupContext

+ func (wgc *WaitGroupContext) Add(delta int)

+ func (wgc *WaitGroupContext) Done()

+ func (wgc *WaitGroupContext) Wait()

Jun 12, 2022

Changes in this version

+ type Task struct

+ func NewTask(taskFunc func() (T, error)) *Task[T]

+ func (task *Task[T]) Call() Future[T]

Nov 21, 2021

Changes in this version

+ func GoroutineID() (uint, error)

+ type Future interface

+ FlatMap func(func(interface{}) (Future, error)) Future

+ Get func() (interface{}, error)

+ Map func(func(interface{}) (interface{}, error)) Future

+ Recover func(func() (interface{}, error)) Future

+ RecoverWith func(Future) Future

+ func FutureFirstCompletedOf(futures ...Future) Future

+ func FutureSeq(futures []Future) Future

+ func FutureTimer(d time.Duration) Future

+ func NewFuture() Future

+ type FutureImpl struct

+ func (fut *FutureImpl) FlatMap(f func(interface{}) (Future, error)) Future

+ func (fut *FutureImpl) Get() (interface{}, error)

+ func (fut *FutureImpl) Map(f func(interface{}) (interface{}, error)) Future

+ func (fut *FutureImpl) Recover(f func() (interface{}, error)) Future

+ func (fut *FutureImpl) RecoverWith(rf Future) Future

+ type OptimisticLock struct

+ func NewOptimisticLock() *OptimisticLock

+ func (o *OptimisticLock) Lock()

+ func (o *OptimisticLock) OptLock() int64

+ func (o *OptimisticLock) OptUnlock(stamp int64) bool

+ func (o *OptimisticLock) RLock()

+ func (o *OptimisticLock) RUnlock()

+ func (o *OptimisticLock) Unlock()

+ type Promise interface

+ Failure func(error)

+ Future func() Future

+ Success func(interface{})

+ func NewPromise() Promise

+ type PromiseImpl struct

+ func (p *PromiseImpl) Failure(e error)

+ func (p *PromiseImpl) Future() Future

+ func (p *PromiseImpl) Success(value interface{})

+ type ReentrantLock struct

+ func NewReentrantLock() *ReentrantLock

+ func (r *ReentrantLock) Lock()

+ func (r *ReentrantLock) Unlock()