Module stormpot
Package stormpot

Interface Reallocator<T extends Poolable>

  • Type Parameters:
    T - any type that implements Poolable.
    All Superinterfaces:
    Allocator<T>
    public interface Reallocator<T extends Poolable>
extends Allocator<T>

    Reallocators are a special kind of Allocator that can reallocate Poolables that have expired. This is useful since the Pool will typically keep the Poolables around for a relatively long time, with respect to garbage collection. Because of this, there is a high chance that the Poolables tenure to the old generation during their life time. This way, pools often cause a slow, but steady accretion of old generation garbage, ultimately helping to increase the frequency of expensive full collections.

    The accretion of old generation garbage is inevitable, but the rate can be slowed by reusing as much as possible of the Poolable instances, when they are to be reallocated. This interface is only here to enable this optimisation, and implementing it is completely optional.

    Since:
    2.2
    Author:
    Chris Vest <mr.chrisvest@gmail.com>

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      T reallocate​(Slot slot, T poolable)
      Possibly reallocate the given instance of T for the given slot, and return it if the reallocation was successful, or a fresh replacement if the instance could not be reallocated.

    • Method Detail

      • reallocate

        T reallocate​(Slot slot,
             T poolable)
      throws java.lang.Exception

        Possibly reallocate the given instance of T for the given slot, and return it if the reallocation was successful, or a fresh replacement if the instance could not be reallocated.

        This method is effectively equivalent to the following:

              deallocate(poolable);
      return allocate(slot);

        With the only difference that it may, if possible, reuse the given expired Poolable, either wholly or in part.

        The state stored in the SlotInfo for the object is reset upon reallocation, just like it would be in the case of a normal deallocation-allocation cycle.

        Exceptions thrown by this method may propagate out through the claim method of a pool, in the form of being wrapped inside a PoolException. Pools must be able to handle these exceptions in a sane manner, and are guaranteed to return to a working state if a Reallocator stops throwing exceptions from its reallocate method.

        Be aware that if the reallocation of an object fails with an exception, then no attempts will be made to explicitly deallocate that object. This way, a failed reallocation is implicitly understood to effectively be a successful deallocation.

        Parameters:
        slot - The slot the pool wish to allocate an object for. Implementers do not need to concern themselves with the details of a pools slot objects. They just have to call release on them as the protocol demands.
        poolable - The non-null Poolable instance to be reallocated.
        Returns:
        A fresh or rejuvenated instance of T. Never null.
        Throws:
        java.lang.Exception - If the allocation fails.
        See Also:
        Allocator.allocate(Slot), Allocator.deallocate(Poolable)