Caffeine cache 3.1.8 · com.github.benmanes.caffeine.cache.LocalLoadingCache

Modifier and Type	Field and Description
public static final System.Logger	logger

Method Summary

Modifier and Type	Method and Description
public @Nullable Function<Set<? extends K>, Map<K, V>>	bulkMappingFunction() Returns the `CacheLoader#loadAll` as a mapping function, if implemented.
public AsyncCacheLoader<? super K, V>	cacheLoader() Returns the `AsyncCacheLoader` used by this cache.
public default V	get(K the key with which the specified value is to be associated key) Implements com.github.benmanes.caffeine.cache.LoadingCache.get. Returns the value associated with the `key` in this cache, obtaining that value from `CacheLoader#load(Object)` if necessary.
public default Map<K, V>	getAll(Iterable<? extends K> the keys whose associated values are to be returned keys) Implements com.github.benmanes.caffeine.cache.LoadingCache.getAll. Returns a map of the values associated with the `keys`, creating or retrieving those values if necessary.
public static boolean	hasLoadAll(CacheLoader<?, ?> loader) Returns whether the supplied cache loader has bulk load functionality.
public default Map<K, V>	loadSequentially(Iterable<? extends K> keys) Sequentially loads each missing entry.
public Function<K, V>	mappingFunction() Returns the `CacheLoader#load` as a mapping function.
public static <K, V> @Nullable Function<Set<? extends K>, Map<K, V>>	newBulkMappingFunction(CacheLoader<? super K, V> cacheLoader) Returns a mapping function that adapts to `CacheLoader#loadAll`, if implemented.
public static <K, V> Function<K, V>	newMappingFunction(CacheLoader<? super K, V> cacheLoader) Returns a mapping function that adapts to `CacheLoader#load`.
public default CompletableFuture<V>	refresh(K key with which a value may be associated key) Implements com.github.benmanes.caffeine.cache.LoadingCache.refresh. Loads a new value for the `key`, asynchronously.
public default CompletableFuture<Map<K, V>>	refreshAll(Iterable<? extends K> the keys whose associated values are to be returned keys) Implements com.github.benmanes.caffeine.cache.LoadingCache.refreshAll. Loads a new value for each `key`, asynchronously.

Inherited from com.github.benmanes.caffeine.cache.LocalManualCache:: asMap bulkLoad cache cleanUp estimatedSize get getAll getAllPresent getIfPresent invalidate invalidateAll invalidateAll put putAll stats

logger	back to summary
public static final System.Logger logger

Method Detail

bulkMappingFunction	back to summary
public @Nullable Function<Set<? extends K>, Map<K, V>> bulkMappingFunction() Returns the `CacheLoader#loadAll` as a mapping function, if implemented.

cacheLoader	back to summary
public AsyncCacheLoader<? super K, V> cacheLoader() Returns the `AsyncCacheLoader` used by this cache.

get back to summary

get	back to summary
public default V get(K key) Implements com.github.benmanes.caffeine.cache.LoadingCache.get. Doc from com.github.benmanes.caffeine.cache.LoadingCache.get. Returns the value associated with the `key` in this cache, obtaining that value from `CacheLoader#load(Object)` if necessary. If another call to `get` is currently loading the value for the `key`, this thread simply waits for that thread to finish and returns its loaded value. Note that multiple threads can concurrently load values for distinct keys. If the specified key is not already associated with a value, attempts to compute its value 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. Some attempted update operations on this cache by other threads may be blocked while the computation is in progress, so the computation should be short and simple, and must not attempt to update any other mappings of this cache. Parameters key:K the key with which the specified value is to be associated Returns:V the current (existing or computed) value associated with the specified key, or null if the computed value is null Annotations @Override @SuppressWarnings:NullAway

public default V get(K key)

Implements com.github.benmanes.caffeine.cache.LoadingCache.get.

Doc from com.github.benmanes.caffeine.cache.LoadingCache.get.

Returns the value associated with the key in this cache, obtaining that value from CacheLoader#load(Object) if necessary.

If another call to get is currently loading the value for the key, this thread simply waits for that thread to finish and returns its loaded value. Note that multiple threads can concurrently load values for distinct keys.

If the specified key is not already associated with a value, attempts to compute its value 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. Some attempted update operations on this cache by other threads may be blocked while the computation is in progress, so the computation should be short and simple, and must not attempt to update any other mappings of this cache.

Parameters

key:K: the key with which the specified value is to be associated

Returns:V

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

Annotations

@Override
@SuppressWarnings:NullAway

getAll back to summary

getAll	back to summary
public default Map<K, V> getAll(Iterable<? extends K> keys) Implements com.github.benmanes.caffeine.cache.LoadingCache.getAll. Doc from com.github.benmanes.caffeine.cache.LoadingCache.getAll. Returns a map of the values associated with the `keys`, creating or retrieving those values if necessary. The returned map contains entries that were already cached, combined with the newly loaded entries; it will never contain null keys or values. Caches loaded by a `CacheLoader` will issue a single request to `CacheLoader#loadAll` for all keys which are not already present in the cache. All entries returned by `CacheLoader#loadAll` will be stored in the cache, overwriting any previously cached values. If another call to `get` tries to load the value for a key in `keys`, implementations may either have that thread load the entry or simply wait for this thread to finish and return the loaded value. In the case of overlapping non-blocking loads, the last load to complete will replace the existing entry. Note that multiple threads can concurrently load values for distinct keys. Note that duplicate elements in `keys`, as determined by `Object#equals`, will be ignored. Parameters keys:Iterable<? extends K> the keys whose associated values are to be returned Returns:Map<K, V> an unmodifiable mapping of keys to values for the specified keys in this cache Annotations @Override

public default Map<K, V> getAll(Iterable<? extends K> keys)

Implements com.github.benmanes.caffeine.cache.LoadingCache.getAll.

Doc from com.github.benmanes.caffeine.cache.LoadingCache.getAll.

Returns a map of the values associated with the keys, creating or retrieving those values if necessary. The returned map contains entries that were already cached, combined with the newly loaded entries; it will never contain null keys or values.

Caches loaded by a CacheLoader will issue a single request to CacheLoader#loadAll for all keys which are not already present in the cache. All entries returned by CacheLoader#loadAll will be stored in the cache, overwriting any previously cached values. If another call to get tries to load the value for a key in keys, implementations may either have that thread load the entry or simply wait for this thread to finish and return the loaded value. In the case of overlapping non-blocking loads, the last load to complete will replace the existing entry. Note that multiple threads can concurrently load values for distinct keys.

Note that duplicate elements in keys, as determined by Object#equals, will be ignored.

Parameters

keys:Iterable<? extends K>: the keys whose associated values are to be returned

Returns:Map<K, V>

an unmodifiable mapping of keys to values for the specified keys in this cache

Annotations

@Override

hasLoadAll	back to summary
public static boolean hasLoadAll(CacheLoader<?, ?> loader) Returns whether the supplied cache loader has bulk load functionality.

loadSequentially	back to summary
public default Map<K, V> loadSequentially(Iterable<? extends K> keys) Sequentially loads each missing entry.

mappingFunction	back to summary
public Function<K, V> mappingFunction() Returns the `CacheLoader#load` as a mapping function.

newBulkMappingFunction	back to summary
public static <K, V> @Nullable Function<Set<? extends K>, Map<K, V>> newBulkMappingFunction(CacheLoader<? super K, V> cacheLoader) Returns a mapping function that adapts to `CacheLoader#loadAll`, if implemented.

newMappingFunction	back to summary
public static <K, V> Function<K, V> newMappingFunction(CacheLoader<? super K, V> cacheLoader) Returns a mapping function that adapts to `CacheLoader#load`.

refresh back to summary

refresh	back to summary
public default CompletableFuture<V> refresh(K key) Implements com.github.benmanes.caffeine.cache.LoadingCache.refresh. Doc from com.github.benmanes.caffeine.cache.LoadingCache.refresh. Loads a new value for the `key`, 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 `System.Logger`) and swallowed. Caches loaded by a `CacheLoader` will call `CacheLoader#reload` if the cache currently contains a value for the `key`, and `CacheLoader#load` otherwise. Loading is asynchronous by delegating to the default executor. Returns an existing future without doing anything if another thread is currently loading the value for `key`. Parameters key:K key with which a value may be associated Returns:CompletableFuture<V> the future that is loading the value Annotations @Override @SuppressWarnings:FutureReturnValueIgnored

public default CompletableFuture<V> refresh(K key)

Implements com.github.benmanes.caffeine.cache.LoadingCache.refresh.

Doc from com.github.benmanes.caffeine.cache.LoadingCache.refresh.

Loads a new value for the key, 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 System.Logger) and swallowed.

Caches loaded by a CacheLoader will call CacheLoader#reload if the cache currently contains a value for the key, and CacheLoader#load otherwise. Loading is asynchronous by delegating to the default executor.

Returns an existing future without doing anything if another thread is currently loading the value for key.

Parameters

key:K: key with which a value may be associated

Returns:CompletableFuture<V>

the future that is loading the value

Annotations

@Override
@SuppressWarnings:FutureReturnValueIgnored

refreshAll back to summary

refreshAll	back to summary
public default CompletableFuture<Map<K, V>> refreshAll(Iterable<? extends K> keys) Implements com.github.benmanes.caffeine.cache.LoadingCache.refreshAll. Doc from com.github.benmanes.caffeine.cache.LoadingCache.refreshAll. Loads a new value for each `key`, 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 `System.Logger`) and swallowed. If another thread is currently loading the value for `key`, then this method does not perform an additional load. Caches loaded by a `CacheLoader` will call `CacheLoader#reload` if the cache currently contains a value for the `key`, and `CacheLoader#load` otherwise. Loading is asynchronous by delegating to the default executor. Parameters keys:Iterable<? extends K> the keys whose associated values are to be returned Returns:CompletableFuture<Map<K, V>> a future containing an unmodifiable mapping of keys to values for the specified keys that are loading the values Annotations @Override

public default CompletableFuture<Map<K, V>> refreshAll(Iterable<? extends K> keys)

Implements com.github.benmanes.caffeine.cache.LoadingCache.refreshAll.

Doc from com.github.benmanes.caffeine.cache.LoadingCache.refreshAll.

Loads a new value for each key, 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 System.Logger) and swallowed. If another thread is currently loading the value for key, then this method does not perform an additional load.

Parameters

keys:Iterable<? extends K>: the keys whose associated values are to be returned

Returns:CompletableFuture<Map<K, V>>

a future containing an unmodifiable mapping of keys to values for the specified keys that are loading the values

Annotations

@Override

pack-priv Interface LocalLoadingCache<K, V>

Field Summary

Method Summary

Field Detail

Method Detail