All Classes and Interfaces

Class
Description
This class provides a skeletal implementation of the LinkedDeque interface to minimize the effort required to implement this interface.
A linked deque implementation used to represent an access-order queue.
An element that is linked on the Deque.
Static utility methods and classes pertaining to asynchronous operations.
A removal listener that asynchronously forwards the value stored in a CompletableFuture if successful to the user-supplied removal listener.
A weigher for asynchronous computations.
Computes or retrieves values asynchronously, based on a key, for use in populating a AsyncLoadingCache.
A semi-persistent mapping from keys to values.
 
 
 
 
 
 
 
The namespace for field padding through inheritance.
 
 
Enforces a memory layout to avoid false sharing by padding the write count.
Enforces a memory layout to avoid false sharing by padding the read count.
The namespace for field padding through inheritance.
Enforces a memory layout to avoid false sharing by padding the drain status.
 
A striped, non-blocking, bounded buffer.
 
An in-memory cache implementation that supports full concurrency of retrievals, a high expected concurrency for updates, and multiple ways to bound the cache.
 
 
 
 
An adapter to safely externalize the entry iterator.
An adapter to safely externalize the entries.
An adapter to safely externalize the entry spliterator.
An adapter to safely externalize the key iterator.
An adapter to safely externalize the keys.
An adapter to safely externalize the key spliterator.
An adapter to safely externalize the value iterator.
An adapter to safely externalize the value spliterator.
An adapter to safely externalize the values.
 
A multiple-producer / single-consumer buffer that rejects new elements if it is full or fails spuriously due to contention.
A semi-persistent mapping from keys to values.
Computes or retrieves values, based on a key, for use in populating a LoadingCache or AsyncLoadingCache.
Statistics about the performance of a Cache.
Communicates the write or deletion of a value, based on a key, to an external resource.
A builder of AsyncLoadingCache, LoadingCache, and Cache instances having a combination of the following features: automatic loading of entries into the cache, optionally asynchronously size-based eviction when a maximum is exceeded based on frequency and recency time-based expiration of entries, measured since last access or last write asynchronously refresh when the first stale request for an entry occurs keys automatically wrapped in weak references values automatically wrapped in weak or soft references writes propagated to an external resource notification of evicted (or otherwise removed) entries accumulation of cache access statistics
 
A specification of a Caffeine builder configuration.
A thread-safe StatsCounter implementation for use by Cache implementors.
 
A StatsCounter implementation that does not record any cache events.
 
 
A probabilistic multiset for estimating the popularity of an element within a time window.
A StatsCounter implementation that suppresses and logs any exception thrown by the delegate statsCounter.
A linked list extension of the Deque interface where the link pointers are tightly integrated with the element.
 
A semi-persistent mapping from keys to values.
This class provides a skeletal implementation of the AsyncLoadingCache interface to minimize the effort required to implement a LocalCache.
 
An in-memory cache providing thread safety and atomicity guarantees.
WARNING: GENERATED CODE A factory for caches optimized for a particular configuration.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This class provides a skeletal implementation of the LoadingCache interface to minimize the effort required to implement a LocalCache.
This class provides a skeletal implementation of the Cache interface to minimize the effort required to implement a LocalCache.
 
 
An MPSC array queue which starts at initialCapacity and grows to maxCapacity in linked chunks of the initial size.
An entry in the cache containing the key, value, weight, access, and write metadata.
WARNING: GENERATED CODE A factory for cache nodes optimized for a particular configuration.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A non-reentrant mutual exclusion Lock.
A non-fair lock using AQS state to represent if the lock is held.
An access point for inspecting and performing low-level operations based on the cache's runtime characteristics.
The low-level operations for a cache with a size-based eviction policy.
The low-level operations for a cache with a expiration policy.
Static utility methods and classes pertaining to weak and soft references.
A weak or soft reference that includes the entry's key reference.
A short-lived adapter used for looking up an entry in the cache where the keys are weakly held.
The value in a cache that holds values softly.
The key in a cache that holds keys weakly.
The value in a cache that holds values weakly.
The reason why a cached entry was removed.
An object that can receive a notification when an entry is removed from a cache.
The namespace for field padding through inheritance.
Enforces a memory layout to avoid false sharing by padding the tail node.
Enforces a memory layout to avoid false sharing by padding the head node.
 
 
Serializes the configuration of the cache, reconsitituting it as a Cache, LoadingCache, or AsyncLoadingCache using Caffeine upon deserialization.
A lock-free unbounded queue based on linked nodes that supports concurrent producers and is restricted to a single consumer.
 
 
A proxy that is serialized instead of the queue.
 
Accumulates statistics during the operation of a Cache for presentation by Cache.stats().
A base class providing the mechanics for supporting dynamic striping of bounded buffers.
 
A time source that returns a time value representing the number of nanoseconds elapsed since some fixed but arbitrary point in time.
An in-memory cache that has no capabilities for bounding the map.
An adapter to safely externalize the entry iterator.
An adapter to safely externalize the entries.
An adapter to safely externalize the entry spliterator.
An adapter to safely externalize the key iterator.
An adapter to safely externalize the keys.
 
 
 
An eviction policy that supports no boundings.
An adapter to safely externalize the value iterator.
An adapter to safely externalize the values.
Static access to Unsafe and convenient utility methods for performing low-level, unsafe operations.
A concurrent access enabling class used by circular array based queues this class exposes an offset computation method along with differently memory fenced load/store methods into the underlying array.
Calculates the weights of cache entries.
A linked deque implementation used to represent a write-order queue.
An element that is linked on the Deque.
An entry that allows updates to write through to the backing map.