public abstract class AbstractLoadingCache<K,V> extends AbstractCache<K ,V> implements LoadingCache <K ,V>
Cache
interface to minimize the effort required to implement this interface.
To implement a cache, the programmer needs only to extend this class and provide an implementation for the LoadingCache
and Cache
methods. getUnchecked(K)
, AbstractCache
, and getAll(java.lang.Iterable<? extends K>)
are implemented in terms of get
; AbstractCache
is implemented in terms of getIfPresent
; AbstractCache
is implemented in terms of AbstractCache
, AbstractCache
is implemented in terms of AbstractCache
. The method AbstractCache
is a no-op. All other methods throw an UnsupportedOperationException
.
AbstractCache.SimpleStatsCounter , AbstractCache.StatsCounter
Modifier | Constructor and Description |
---|---|
protected |
AbstractLoadingCache()
Constructor for use by subclasses.
|
Modifier and Type | Method and Description |
---|---|
V |
apply(K key)
Returns the result of applying this function to
input .
|
ImmutableMap |
getAll(Iterable
Returns a map of the values associated with
keys , creating or retrieving those values if necessary.
|
V |
getUnchecked(K key)
Returns the value associated with
key in this cache, first loading that value if necessary.
|
void |
refresh(K key)
Loads a new value for key
key , possibly asynchronously.
|
asMap, cleanUp, get, getAllPresent, invalidate, invalidateAll, invalidateAll, put, putAll, size, stats
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
asMap, get
cleanUp, get, getAllPresent, getIfPresent, invalidate, invalidateAll, invalidateAll, put, putAll, size, stats
protected AbstractLoadingCache()
public V getUnchecked(K key)
LoadingCache
key
in this cache, first loading that value if necessary. No observable state associated with this cache is modified until loading completes. Unlike
LoadingCache.get(K)
, this method does not throw a checked exception, and thus should only be used in situations where checked exceptions are not thrown by the cache loader.
If another call to LoadingCache
or LoadingCache
is currently loading the value for key
, simply waits for that thread to finish and returns its loaded value. Note that multiple threads can concurrently load values for distinct keys.
Caches loaded by a CacheLoader
will call CacheLoader
to load new values into the cache. Newly loaded values are added to the cache using Cache.asMap().putIfAbsent
after loading has completed; if another value was associated with key
while the new value was loading then a removal notification will be sent for the new value.
Warning: this method silently converts checked exceptions to unchecked exceptions, and should not be used with cache loaders which throw checked exceptions. In such cases use LoadingCache
instead.
public ImmutableMap<K ,V> getAll(Iterable <? extends K> keys) throws ExecutionException
LoadingCache
keys
, creating or retrieving those values if necessary. The returned map contains entries that were already cached, combined with newly loaded entries; it will never contain null keys or values.
Caches loaded by a CacheLoader
will issue a single request to CacheLoader
for all keys which are not already present in the cache. All entries returned by CacheLoader
will be stored in the cache, over-writing any previously cached values. This method will throw an exception if CacheLoader
returns null
, returns a map containing null keys or values, or fails to return an entry for each requested key.
Note that duplicate elements in keys
, as determined by Object
, will be ignored.
getAll
in interface
LoadingCache<K,V>
ExecutionException
- if a checked exception was thrown while loading the value. (
ExecutionException
is thrown
even if computation was interrupted by an InterruptedException
.)
public final V apply(K key)
Function
input
. This method is
generally expected, but not absolutely required, to have the following properties:
Objects.equal
(a, b)
implies that Objects.equal(function.apply(a), function.apply(b))
. public void refresh(K key)
LoadingCache
key
, possibly asynchronously. While the new value is loading the previous value (if any) will continue to be returned by
get(key)
unless it is evicted. If the new value is loaded successfully it will replace the previous value in the cache; if an exception is thrown while refreshing the previous value will remain,
and the exception will be logged (using Logger
) and swallowed.
Caches loaded by a CacheLoader
will call CacheLoader
if the cache currently contains a value for key
, and CacheLoader
otherwise. Loading is asynchronous only if CacheLoader
was overridden with an asynchronous implementation.
Returns without doing anything if another thread is currently loading the value for key
. If the cache loader associated with this cache performs refresh asynchronously then this method may return before refresh completes.