K
- the type of keys maintained by this cacheV
- the type of mapped valuespublic interface AsyncLoadingCache<K,V> extends AsyncCache<K,V>
Implementations of this interface are expected to be thread-safe, and can be safely accessed by multiple concurrent threads.
Modifier and Type | Method and Description |
---|---|
default @NonNull ConcurrentMap<K,CompletableFuture<V>> |
asMap()
Returns a view of the entries stored in this cache as a thread-safe map.
|
@NonNull CompletableFuture<V> |
get(K key)
Returns the future associated with
key in this cache, obtaining that value from
AsyncCacheLoader.asyncLoad(K, java.util.concurrent.Executor) if necessary. |
@NonNull CompletableFuture<Map<K,V>> |
getAll(@NonNull Iterable<? extends K> keys)
Returns the future of a map of the values associated with
keys , creating or retrieving
those values if necessary. |
@NonNull LoadingCache<K,V> |
synchronous()
Returns a view of the entries stored in this cache as a synchronous
LoadingCache . |
get, get, getAll, getAll, getIfPresent, put
@NonNull CompletableFuture<V> get(K key)
key
in this cache, obtaining that value from
AsyncCacheLoader.asyncLoad(K, java.util.concurrent.Executor)
if necessary. If the asynchronous computation fails, the
entry will be automatically removed from this cache.
If the specified key is not already associated with a value, attempts to compute its value
asynchronously and enters it into this cache unless null
. The entire method invocation
is performed atomically, so the function is applied at most once per key.
key
- key with which the specified value is to be associatedNullPointerException
- if the specified key is null or if the future returned by the
AsyncCacheLoader
is nullRuntimeException
- or Error if the AsyncCacheLoader
does when constructing the
future, in which case the mapping is left unestablished@NonNull CompletableFuture<Map<K,V>> getAll(@NonNull Iterable<? extends K> keys)
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. If the any of the
asynchronous computations fail, those entries will be automatically removed from this cache.
Caches loaded by a AsyncCacheLoader
supporting bulk loading will issue a single request
to AsyncCacheLoader.asyncLoadAll(java.lang.Iterable<? extends K>, java.util.concurrent.Executor)
for all keys which are not already present in the
cache. If another call to get(K)
tries to load the value for a key in keys
, that
thread retrieves a future that is completed by this bulk computation. Caches that do not use a
AsyncCacheLoader
with an optimized bulk load implementation will sequentially load each
key by making individual AsyncCacheLoader.asyncLoad(K, java.util.concurrent.Executor)
calls. Note that multiple threads
can concurrently load values for distinct keys.
Note that duplicate elements in keys
, as determined by Object.equals(java.lang.Object)
, will be
ignored.
keys
- the keys whose associated values are to be returnedNullPointerException
- if the specified collection is null or contains a null element, or
if the future returned by the AsyncCacheLoader
is nullRuntimeException
- or Error if the AsyncCacheLoader
does so, if
AsyncCacheLoader.asyncLoadAll(java.lang.Iterable<? extends K>, java.util.concurrent.Executor)
returns null
, or fails when constructing
the future, in which case the mapping is left unestablisheddefault @NonNull ConcurrentMap<K,CompletableFuture<V>> asMap()
Iterators from the returned map are at least weakly consistent: they are safe for concurrent use, but if the cache is modified (including by eviction) after the iterator is created, it is undefined which of the changes (if any) will be reflected in that iterator.
asMap
in interface AsyncCache<K,V>
Map
operations@NonNull LoadingCache<K,V> synchronous()
LoadingCache
. A
mapping is not present if the value is currently being loaded. Modifications made to the
synchronous cache directly affect the asynchronous cache. If a modification is made to a
mapping that is currently loading, the operation blocks until the computation completes.synchronous
in interface AsyncCache<K,V>