SlotInfo and Poolable instance, only a single thread will
invoke the expiration at a time. This means that there is no need to
synchronise on the SlotInfo or Poolable objects.
The easiest way to ensure that an Expiration implementation is thread-safe,
is to make sure that they never mutate any state. If they do, however,
then they must do so in a thread-safe manner, unless the mutable state is
contained within the SlotInfo or Poolable objects – in this case, the
mutable state will be thread-local. Be aware that making the
hasExpired method `synchronized` will
most likely severely reduce the performance and scalability of the pool.
The Expiration can be invoked several times during a
claim call, so it is important that the
Expiration is fast. It can easily be the dominating factor in the
performance of the pool.
[TIP]
--
If the expiration is too slow, you can use
every(long, TimeUnit) or every(long, long, TimeUnit) to
make an expiration that only performs the slow expiration check every few
seconds, for instance.
You can alternatively use a time-based expiration, such as
after(long, TimeUnit), that has been configured with a very low
expiration time, like a few seconds. Then you can configure the pool to use
a stormpot.Reallocator , where you do the expensive expiration check
in the reallocate
method, returning the same Poolable back if it hasn't expired.
Be aware, though, that such a scheme has to be tuned to the load of the
application, such that the objects in the pool don't all expire at the same
time, leaving the pool empty.
--
| Modifier and Type | Method and Description |
|---|---|
| public static < The type of T extends Poolable> ExpirationPoolable to check. | Returns: The specified time-based expiration policy.Poolables older than this, in the given unit, will
be considered expired. This value must be at least 1. time, TimeUnit The unit)TimeUnit of the maximum permitted age.
Never `null`.Construct a new Expiration that will invalidate objects that are older than the exact provided span of time in the given unit. |
| public static < The type of T extends Poolable> ExpirationPoolable to check. | Returns: The specified time-based expiration policy.Poolables younger than this, in the given unit, are not
considered expired. This value must be at least 1. fromTime, long Poolables older than this, in the given unit, are always
considered expired. This value must be greater than or equal
to the lowerBound. toTime, TimeUnit The unit)TimeUnit of the bounds values. Never `null`.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. |
| public default Expiration | Returns: An expiration that only delegates to this one every so often.The time between checks. time, TimeUnit The unit of the time between checks. unit)Construct a new Expiration that is composed of a time-based expiration and this one, such that this expiration is only consulted at most once within the given time period. |
| public default Expiration | Returns: An expiration that only delegates to this one every so often.The minimum amount of time before a check becomes necessary. fromTime, long The maximum amount of time before a check becomes necessary. toTime, TimeUnit The unit of the time between checks. unit)Construct a new Expiration that is composed of a time-based expiration and this one, such that this expiration is only consulted at most once within a time period based on the given `fromTime` and `toTime` brackets. |
| public boolean | Returns: `true` if the Slot and Poolable in question should be deallocated, `false` if it is valid and eligible for claiming.An informative representative of the slot being tested.
Never `null`. info)Test whether the Slot and Poolable object, represented by the given
|
| public static < The type of T extends Poolable> ExpirationPoolable to check. | Returns: An expiration that never invalidates objects.Construct a new Expiration that never invalidates any objects. |
| public default Expiration | Returns: A new expiration composed of this and the other expiration.The other expiration to compose with. other)Construct a new Expiration that will invalidate objects if either this, or the given expiration, considers an object expired. |
| after | back to summary |
|---|---|
| public static <T extends Poolable> Expiration Construct a new Expiration that will invalidate objects that are older
than the exact provided span of time in the given unit.
This expiration does not make use of the
slot info stamp.
If the `time` is less than one, or the `unit` is `null`, then
an
| |
| after | back to summary |
|---|---|
| public static <T extends Poolable> Expiration 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.
The actual expiration time is chosen uniformly randomly within the
given brackets, for each allocated object.
This expiration make use of the
slot info stamp for storing the target
expiration timestamp.
If the `fromTime` is less than 1, the `toTime` is less than the
`fromTime`, or the `unit` is `null`, then an
| |
| every | back to summary |
|---|---|
| public default Expiration Construct a new Expiration that is composed of a time-based expiration and this one, such that this expiration is only consulted at most once within the given time period. For instance, if an expiration is expensive, you can use this to only check it, say, every 5 seconds.
| |
| every | back to summary |
|---|---|
| public default Expiration Construct a new Expiration that is composed of a time-based expiration and this one, such that this expiration is only consulted at most once within a time period based on the given `fromTime` and `toTime` brackets. For instance, if an expiration is expensive, you can use this to only check it, say, every 5 to 10 seconds.
| |
| hasExpired | back to summary |
|---|---|
| public boolean hasExpired(SlotInfo<? extends T> info) throws Exception Test whether the Slot and Poolable object, represented by the given
| |
| never | back to summary |
|---|---|
| public static <T extends Poolable> Expiration Construct a new Expiration that never invalidates any objects. This is useful for effectively disabling object expiration, for cases where that makes sense.
| |
| or | back to summary |
|---|---|
| public default Expiration Construct a new Expiration that will invalidate objects if either this, or the given expiration, considers an object expired. This is a short-circuiting combinator, such that if this expiration invalidates the object, then the other expiration will not be checked. This makes it easy to have an expiration that expires both on time, and some other criteria.
| |