Uses of Interface
stormpot.Poolable

Packages that use Poolable

Package	Description
stormpot	Stormpot
stormpot.internal

Uses of Poolable in stormpot

Classes in stormpot with type parameters of type Poolable

Modifier and Type	Interface	Description
interface	Allocator<T extends Poolable>	An Allocator is responsible for the creation and destruction of Poolable objects.
interface	Expiration<T extends Poolable>	The expiration is used to determine if a given slot has expired, or otherwise become invalid.
interface	Pool<T extends Poolable>	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.
interface	PoolBuilder<T extends Poolable>	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.
interface	PoolTap<T extends Poolable>	A PoolTap provides the API for accessing objects in a Pool.
interface	Reallocator<T extends Poolable>	Reallocators are a special kind of Allocator that can reallocate Poolables that have expired.
interface	SlotInfo<T extends Poolable>	An informative interface, used by Expiration instances to determine if a slot has expired or is still invalid for claiming.

Classes in stormpot that implement Poolable

Modifier and Type	Class	Description
class	BasePoolable	A basic implementation of the Poolable interface, which can be extended directly.
class	Pooled<T>	A reference to a pooled object.

Methods in stormpot with type parameters of type Poolable

Modifier and Type	Method	Description
static <T extends Poolable> Expiration<T>	Expiration.after(long fromTime, long toTime, TimeUnit unit)	Construct a new Expiration that will invalidate objects that are older than the given lower bound, before they get older than the upper bound, in the given time unit.
static <T extends Poolable> Expiration<T>	Expiration.after(long time, TimeUnit unit)	Construct a new Expiration that will invalidate objects that are older than the exact provided span of time in the given unit.
static <T extends Poolable> PoolBuilder<T>	Pool.from(Allocator<T> allocator)	Get a PoolBuilder based on the given Allocator or Reallocator, which can then in turn be used to build a Pool instance with the desired configuration.
static <T extends Poolable> PoolBuilder<T>	Pool.fromInline(Allocator<T> allocator)	Get a PoolBuilder based on the given Allocator or Reallocator, which can then in turn be used to build a Pool operating in the inline mode, with the desired configuration.
static <T extends Poolable> PoolBuilder<T>	Pool.fromThreaded(Allocator<T> allocator)	Get a PoolBuilder based on the given Allocator or Reallocator, which can then in turn be used to build a threaded Pool instance with the desired configuration.
static <T extends Poolable> Expiration<T>	Expiration.never()	Construct a new Expiration that never invalidates any objects.
<X extends Poolable> PoolBuilder<X>	PoolBuilder.setAllocator(Allocator<X> allocator)	Set the Allocator or Reallocator to use for the pools we want to configure.

Methods in stormpot with parameters of type Poolable

Modifier and Type	Method	Description
void	Slot.expire(Poolable obj)	Mark the object represented by this slot as expired.
void	Slot.release(Poolable obj)	Signal to the pool that the currently claimed object in this slot has been released.

Uses of Poolable in stormpot.internal

Classes in stormpot.internal with type parameters of type Poolable

Modifier and Type	Class	Description
class	AllocationController<T extends Poolable>	An AllocationController implements the actual allocation and deallocation of objects in a pool.
final class	BAllocThread<T extends Poolable>	The dedicated background allocation process of a pool that operates in the AllocationProcessMode.THREADED mode.
final class	BlazePool<T extends Poolable>	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.
final class	BlazePoolSingleThreadedTap<T extends Poolable>	The claim method in this pool tap follows the same idea as the thread-local caching and TLR-claiming in the pool itself.
final class	BlazePoolThreadSafeTap<T extends Poolable>	The claim method in this pool tap offers similar thread-safety and performance to the default thread-safe pool tap.
final class	BlazePoolVirtualThreadSafeTap<T extends Poolable>	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.
class	BSlot<T extends Poolable>	The BSlot implements the Slot and SlotInfo interfaces for the blaze pool implementation.
class	BSlotCache<T extends Poolable>	A reference to a BSlot.
class	BSlotCachePadded<T extends Poolable>	A reference to a BSlot, with extra padding to keep the pointer on its own cache line.
class	BSlotPadded<T extends Poolable>	A BSlot type with extra padding to ensure each slot is on their own CPU cache line.
final class	DirectAllocationController<T extends Poolable>	The AllocationController that implements the AllocationProcessMode.DIRECT mode.
final class	EveryExpiration<T extends Poolable>	The implementation of the Expiration.every(long, TimeUnit) and Expiration.every(long, long, TimeUnit) expiration combinators.
final class	InlineAllocationController<T extends Poolable>	The AllocationController implementation for the AllocationProcessMode.INLINE mode.
final class	OrExpiration<T extends Poolable>	Provides a way to compose Expirations.
final class	PoolBuilderImpl<T extends Poolable>	The PoolBuilder implementation.
class	ReallocatingAdaptor<T extends Poolable>	An adaptor that implements Reallocator in terms of a given Allocator.
final class	RefillPile<T extends Poolable>	A RefillPile can collect objects, in a concurrent and wait-free manner, before releasing them all to a queue.
final class	RefillSlot<T extends Poolable>	The node type of RefillPile.
final class	ThreadedAllocationController<T extends Poolable>	The AllocationController implementation for the AllocationProcessMode.THREADED mode.
final class	TimeExpiration<T extends Poolable>	This is a time based Expiration.
final class	TimeSpreadExpiration<T extends Poolable>	This is the standard time based Expiration.

Fields in stormpot.internal declared as Poolable

Modifier and Type	Field	Description
T	BSlot.obj	The object being pooled.

Methods in stormpot.internal with type parameters of type Poolable

Modifier and Type	Method	Description
<X extends Poolable> PoolBuilder<X>	PoolBuilderImpl.setAllocator(Allocator<X> allocator)

Methods in stormpot.internal with parameters of type Poolable

Modifier and Type	Method	Description
void	BSlot.expire(Poolable obj)
void	BSlot.release(Poolable obj)