software.amazon.jdbc.util.storage

Class SlidingExpirationCache<K,V>

java.lang.Object

software.amazon.jdbc.util.storage.SlidingExpirationCache<K,V>

Direct Known Subclasses:

SlidingExpirationCacheWithCleanupThread

public class SlidingExpirationCache<K,V>
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.Map<K,CacheItem<V>>	cache
protected long	cleanupIntervalNanos
protected java.util.concurrent.atomic.AtomicLong	cleanupTimeNanos
protected ItemDisposalFunc<V>	itemDisposalFunc
protected java.util.concurrent.atomic.AtomicReference<ShouldDisposeFunc<V>>	shouldDisposeFunc

Constructor Summary

Constructors

Constructor and Description
SlidingExpirationCache() A cache that periodically cleans up expired entries.
SlidingExpirationCache(ShouldDisposeFunc<V> shouldDisposeFunc, ItemDisposalFunc<V> itemDisposalFunc) A cache that periodically cleans up expired entries.
SlidingExpirationCache(ShouldDisposeFunc<V> shouldDisposeFunc, ItemDisposalFunc<V> itemDisposalFunc, long cleanupIntervalNanos)

Method Summary

Modifier and Type	Method and Description
protected void	cleanUp()
void	clear() Remove and dispose of all entries in the cache.
V	computeIfAbsent(K key, java.util.function.Function<? super K,? extends V> mappingFunction, long itemExpirationNano) In addition to performing the logic defined by Map.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>), cleans up expired entries if we have hit cleanup time.
V	get(K key, long itemExpirationNano)
java.util.Map<K,V>	getEntries() Get a map copy of all entries in the cache, including expired entries.
V	put(K key, V value, long itemExpirationNano)
void	remove(K key) Cleanup expired entries if we have hit the cleanup time, then remove and dispose the value associated with the given key.
protected void	removeAndDispose(K key)
protected void	removeIfExpired(K key)
void	setCleanupIntervalNanos(long cleanupIntervalNanos) Set the cleanup interval for the cache.
void	setShouldDisposeFunc(ShouldDisposeFunc<V> shouldDisposeFunc)
int	size() Get the current size of the cache, including expired entries.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

cache

protected final java.util.Map<K,CacheItem<V>> cache

cleanupIntervalNanos

protected long cleanupIntervalNanos

cleanupTimeNanos

protected final java.util.concurrent.atomic.AtomicLong cleanupTimeNanos

shouldDisposeFunc

protected final java.util.concurrent.atomic.AtomicReference<ShouldDisposeFunc<V>> shouldDisposeFunc

itemDisposalFunc

protected final ItemDisposalFunc<V> itemDisposalFunc

Constructor Detail

SlidingExpirationCache

public SlidingExpirationCache()

A cache that periodically cleans up expired entries. Fetching an expired entry marks that entry as not-expired and renews its expiration time.

SlidingExpirationCache

public SlidingExpirationCache(ShouldDisposeFunc<V> shouldDisposeFunc,
                              ItemDisposalFunc<V> itemDisposalFunc)

A cache that periodically cleans up expired entries. Fetching an expired entry marks that entry as not-expired and renews its expiration time.

Parameters:

shouldDisposeFunc - a function defining the conditions under which an expired entry should be cleaned up when we hit the cleanup time

itemDisposalFunc - a function that will be called on any item that meets the cleanup criteria at cleanup time. The criteria for cleanup is that the item is both expired and marked for cleanup via a call to shouldDisposeFunc.

SlidingExpirationCache

public SlidingExpirationCache(ShouldDisposeFunc<V> shouldDisposeFunc,
                              ItemDisposalFunc<V> itemDisposalFunc,
                              long cleanupIntervalNanos)

Method Detail

setShouldDisposeFunc

public void setShouldDisposeFunc(ShouldDisposeFunc<V> shouldDisposeFunc)

computeIfAbsent

public V computeIfAbsent(K key,
                         java.util.function.Function<? super K,? extends V> mappingFunction,
                         long itemExpirationNano)

In addition to performing the logic defined by Map.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>), cleans up expired entries if we have hit cleanup time. If an expired entry is requested and we have not hit cleanup time or ShouldDisposeFunc indicated the entry should not be closed, the entry will be marked as non-expired.

Parameters:

key - the key with which the specified value is to be associated

mappingFunction - the function to compute a value

itemExpirationNano - the expiration time of the new or renewed entry

Returns:

the current (existing or computed) value associated with the specified key, or null if the computed value is null

put

public V put(K key,
             V value,
             long itemExpirationNano)

get

public V get(K key,
             long itemExpirationNano)

remove

public void remove(K key)

Cleanup expired entries if we have hit the cleanup time, then remove and dispose the value associated with the given key.

Parameters:

key - the key associated with the value to be removed/disposed

removeAndDispose

protected void removeAndDispose(K key)

removeIfExpired

protected void removeIfExpired(K key)

clear

public void clear()

Remove and dispose of all entries in the cache.

getEntries

public java.util.Map<K,V> getEntries()

Get a map copy of all entries in the cache, including expired entries.

Returns:

a map copy of all entries in the cache, including expired entries

size

public int size()

Get the current size of the cache, including expired entries.

Returns:

the current size of the cache, including expired entries.

cleanUp

protected void cleanUp()

setCleanupIntervalNanos

public void setCleanupIntervalNanos(long cleanupIntervalNanos)

Set the cleanup interval for the cache. At cleanup time, expired entries marked for cleanup via ShouldDisposeFunc (if defined) are disposed.

Parameters:

cleanupIntervalNanos - the time interval defining when we should clean up expired entries marked for cleanup, in nanoseconds