All Classes and Interfaces
Class
Description
An AllocationController implements the actual allocation and deallocation of objects
in a pool.
The allocation process represent the means of building pool-specific
AllocationController instances.The operating mode of an
AllocationProcess.An Allocator is responsible for the creation and destruction of
Poolable objects.The dedicated background allocation process of a pool that operates in the
THREADED mode.A basic implementation of the
Poolable interface, which can be extended directly.BlazePool is a highly optimised
Pool implementation that consists of
a queues of Poolable instances, the access to which is made faster with
clever use of ThreadLocals.The claim method in this pool tap follows the same idea as the thread-local
caching and TLR-claiming in the pool itself.
The claim method in this pool tap offers similar thread-safety and
performance to the default thread-safe pool tap.
The claim method in this pool tap offers similar thread-safety and
performance to the default thread-safe pool tap, but without the use of
ThreadLocal.A reference to a
BSlot.A reference to a
BSlot, with extra padding to keep the pointer on its own cache line.A
BSlot type with extra padding to ensure each slot is on their own CPU cache line.A Completion represents some task that is going to be completed at some
point in the future, or maybe already has completed.
The
AllocationController that implements the DIRECT mode.The implementation of the
Expiration.every(long, TimeUnit) and
Expiration.every(long, long, TimeUnit) expiration combinators.The expiration is used to determine if a given slot has expired, or
otherwise become invalid.
Like
IdentityHashMap, but as a Set with no overhead for storing values.The
AllocationController implementation for the INLINE mode.This is the JMX management interface for Stormpot object pools.
A MetricsRecorder implementation supplies the pool with the ability to
record and report operational metrics.
Convenience functions for operating on relative nanosecond time spans.
Provides a way to compose
Expirations.Exception type used to mark poison conditions on slots or in the pool.
A Pool is a self-renewable set of objects from which one can claim exclusive
access to elements, until they are released back into the pool.
Objects contained in a
Pool must implement the Poolable interface
and adhere to its contract.The
PoolBuilder collects information about how big a pool should be,
and how it should allocate objects, and so on, and finally acts as the
factory for building the pool instances themselves, with the
PoolBuilder.build() method.Container of default, initial settings for a
PoolBuilder.The
PoolBuilder implementation.A holder of permissions, deciding what
PoolBuilder settings are allowed to be changed.A reference to a pooled object.
The PoolException may be thrown by a pool implementation in a number of
circumstances:
If claim is called and the pool needs to
allocate
a new object, but the allocation fails by returning null or throwing an exception.
Likewise if the Reallocator.reallocate(Slot, Poolable) method
return null or throw an exception.
If the Slot.release(Poolable) method is misused, and the pool is
able to detect this.
If the expiration check throws an
exception.
A PoolTap provides the API for accessing objects in a
Pool.Leak detector, used to detect if objects allocated by the pool get garbage collected,
without first being deallocated by the pool.
An adaptor that implements
Reallocator in terms of a given Allocator.A
RefillPile can collect objects, in a concurrent and wait-free manner,
before releasing them all to a queue.The node type of
RefillPile.A Slot represents a location in a Pool where objects can be allocated into,
so that they can be claimed and released.
An informative interface, used by
Expiration instances to
determine if a slot has expired or is still invalid for claiming.An implementation of
Completion based on a wait-free stack.A callback that will be notified when threads block on a given completion.
The
AllocationController implementation for the THREADED mode.This is a time based
Expiration.A Timeout represents the maximum amount of time a caller is willing to wait
for a blocking operation to complete.
This is the standard time based
Expiration.