Package net.sf.ehcache

Class Cache

  • All Implemented Interfaces:
    java.lang.Cloneable, java.util.EventListener, Ehcache, StoreListener, InternalEhcache
    public class Cache
extends java.lang.Object
implements InternalEhcache, StoreListener
    Cache is the central class in ehcache. Caches have Elements and are managed by the CacheManager. The Cache performs logical actions. It delegates physical implementations to its Stores.

    A reference to a Cache can be obtained through the CacheManager. A Cache thus obtained is guaranteed to have status Status.STATUS_ALIVE. This status is checked for any method which throws IllegalStateException and the same thrown if it is not alive. This would normally happen if a call is made after CacheManager.shutdown() is invoked.

    Cache is threadsafe.

    Statistics on cache usage are collected and made available through the getStatistics() methods.

    Various decorators are available for Cache, such as BlockingCache, SelfPopulatingCache and the dynamic proxy ExceptionHandlingDynamicCacheProxy. See each class for details.

    Version:
    $Id$
    Author:
    Greg Luck, Geert Bevin

    • Field Detail

      • DEFAULT_CACHE_NAME

        public static final java.lang.String DEFAULT_CACHE_NAME
        A reserved word for cache names. It denotes a default configuration which is applied to caches created without configuration.
        See Also:
        Constant Field Values

      • NET_SF_EHCACHE_DISABLED

        public static final java.lang.String NET_SF_EHCACHE_DISABLED
        System Property based method of disabling ehcache. If disabled no elements will be added to a cache.

        Set the property "net.sf.ehcache.disabled=true" to disable ehcache.

        This can easily be done using java -Dnet.sf.ehcache.disabled=true in the command line.

        See Also:
        Constant Field Values

      • NET_SF_EHCACHE_USE_CLASSIC_LRU

        public static final java.lang.String NET_SF_EHCACHE_USE_CLASSIC_LRU
        System Property based method of selecting the LruMemoryStore in use up to ehcache 1.5. This is provided for ease of migration.

        Set the property "net.sf.ehcache.use.classic.lru=true" to use the older LruMemoryStore implementation when LRU is selected as the eviction policy.

        This can easily be done using java -Dnet.sf.ehcache.use.classic.lru=true in the command line.

        See Also:
        Constant Field Values

    • Constructor Detail

      • Cache

        public Cache​(CacheConfiguration cacheConfiguration)
        2.0 and higher Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        cacheConfiguration - the configuration that should be used to create the cache with

      • Cache

        public Cache​(CacheConfiguration cacheConfiguration,
             RegisteredEventListeners registeredEventListeners,
             BootstrapCacheLoader bootstrapCacheLoader)
        2.0 and higher Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        cacheConfiguration - the configuration that should be used to create the cache with
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        bootstrapCacheLoader - the BootstrapCacheLoader to use to populate the cache when it is first initialised. Null if none is required.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             boolean overflowToDisk,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds)
        1.0 Constructor.

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        This constructor creates disk stores, if specified, that do not persist between restarts.

        The default expiry thread interval of 120 seconds is used. This is the interval between runs of the expiry thread, where it checks the disk store for expired elements. It is not the the timeToLiveSeconds.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        overflowToDisk - whether to use the disk store
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        Since:
        1.0
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             boolean overflowToDisk,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds)
        1.1 Constructor.

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        overflowToDisk - whether to use the disk store
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        Since:
        1.1
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
             boolean overflowToDisk,
             java.lang.String diskStorePath,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds,
             RegisteredEventListeners registeredEventListeners)
        1.2 Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        memoryStoreEvictionPolicy - one of LRU, LFU and FIFO. Optionally null, in which case it will be set to LRU.
        overflowToDisk - whether to use the disk store
        diskStorePath - this parameter is ignored. CacheManager sets it using setter injection.
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        Since:
        1.2
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
             boolean overflowToDisk,
             java.lang.String diskStorePath,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds,
             RegisteredEventListeners registeredEventListeners,
             BootstrapCacheLoader bootstrapCacheLoader)
        1.2.1 Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        memoryStoreEvictionPolicy - one of LRU, LFU and FIFO. Optionally null, in which case it will be set to LRU.
        overflowToDisk - whether to use the disk store
        diskStorePath - this parameter is ignored. CacheManager sets it using setter injection.
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        bootstrapCacheLoader - the BootstrapCacheLoader to use to populate the cache when it is first initialised. Null if none is required.
        Since:
        1.2.1
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
             boolean overflowToDisk,
             java.lang.String diskStorePath,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds,
             RegisteredEventListeners registeredEventListeners,
             BootstrapCacheLoader bootstrapCacheLoader,
             int maxElementsOnDisk)
        1.2.4 Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        memoryStoreEvictionPolicy - one of LRU, LFU and FIFO. Optionally null, in which case it will be set to LRU.
        overflowToDisk - whether to use the disk store
        diskStorePath - this parameter is ignored. CacheManager sets it using setter injection.
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        bootstrapCacheLoader - the BootstrapCacheLoader to use to populate the cache when it is first initialised. Null if none is required.
        maxElementsOnDisk - the maximum number of Elements to allow on the disk. 0 means unlimited.
        Since:
        1.2.4
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
             boolean overflowToDisk,
             java.lang.String diskStorePath,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds,
             RegisteredEventListeners registeredEventListeners,
             BootstrapCacheLoader bootstrapCacheLoader,
             int maxElementsOnDisk,
             int diskSpoolBufferSizeMB)
        1.3 Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        memoryStoreEvictionPolicy - one of LRU, LFU and FIFO. Optionally null, in which case it will be set to LRU.
        overflowToDisk - whether to use the disk store
        diskStorePath - this parameter is ignored. CacheManager sets it using setter injection.
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        bootstrapCacheLoader - the BootstrapCacheLoader to use to populate the cache when it is first initialised. Null if none is required.
        maxElementsOnDisk - the maximum number of Elements to allow on the disk. 0 means unlimited.
        diskSpoolBufferSizeMB - the amount of memory to allocate the write buffer for puts to the DiskStore.
        Since:
        1.3
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
             boolean overflowToDisk,
             java.lang.String diskStorePath,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds,
             RegisteredEventListeners registeredEventListeners,
             BootstrapCacheLoader bootstrapCacheLoader,
             int maxElementsOnDisk,
             int diskSpoolBufferSizeMB,
             boolean clearOnFlush)
        1.6.0 Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        memoryStoreEvictionPolicy - one of LRU, LFU and FIFO. Optionally null, in which case it will be set to LRU.
        overflowToDisk - whether to use the disk store
        diskStorePath - this parameter is ignored. CacheManager sets it using setter injection.
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        bootstrapCacheLoader - the BootstrapCacheLoader to use to populate the cache when it is first initialised. Null if none is required.
        maxElementsOnDisk - the maximum number of Elements to allow on the disk. 0 means unlimited.
        diskSpoolBufferSizeMB - the amount of memory to allocate the write buffer for puts to the DiskStore.
        clearOnFlush - whether the in-memory storage should be cleared when flush() is called on the cache
        Since:
        1.6.0
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

      • Cache

        public Cache​(java.lang.String name,
             int maxElementsInMemory,
             MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
             boolean overflowToDisk,
             java.lang.String diskStorePath,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds,
             boolean diskPersistent,
             long diskExpiryThreadIntervalSeconds,
             RegisteredEventListeners registeredEventListeners,
             BootstrapCacheLoader bootstrapCacheLoader,
             int maxElementsOnDisk,
             int diskSpoolBufferSizeMB,
             boolean clearOnFlush,
             boolean isTerracottaClustered,
             boolean terracottaCoherentReads)
        1.7.0 Constructor

        The ConfigurationFactory and clients can create these.

        A client can specify their own settings here and pass the Cache object into CacheManager.addCache(java.lang.String) to specify parameters other than the defaults.

        Only the CacheManager can initialise them.

        Parameters:
        name - the name of the cache. Note that "default" is a reserved name for the defaultCache.
        maxElementsInMemory - the maximum number of elements in memory, before they are evicted (0 == no limit)
        memoryStoreEvictionPolicy - one of LRU, LFU and FIFO. Optionally null, in which case it will be set to LRU.
        overflowToDisk - whether to use the disk store
        diskStorePath - this parameter is ignored. CacheManager sets it using setter injection.
        eternal - whether the elements in the cache are eternal, i.e. never expire
        timeToLiveSeconds - the default amount of time to live for an element from its creation date
        timeToIdleSeconds - the default amount of time to live for an element from its last accessed or modified date
        diskPersistent - whether to persist the cache to disk between JVM restarts
        diskExpiryThreadIntervalSeconds - how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
        registeredEventListeners - a notification service. Optionally null, in which case a new one with no registered listeners will be created.
        bootstrapCacheLoader - the BootstrapCacheLoader to use to populate the cache when it is first initialised. Null if none is required.
        maxElementsOnDisk - the maximum number of Elements to allow on the disk. 0 means unlimited.
        diskSpoolBufferSizeMB - the amount of memory to allocate the write buffer for puts to the DiskStore.
        clearOnFlush - whether the in-memory storage should be cleared when flush() is called on the cache
        isTerracottaClustered - whether to cluster this cache with Terracotta
        terracottaCoherentReads - whether this cache should use coherent reads (usually should be true) unless optimizing for read-only
        Since:
        1.7.0
        See Also:
        Cache(CacheConfiguration, RegisteredEventListeners, BootstrapCacheLoader), for full construction support of version 2.0 and higher features.

    • Method Detail

      • getTransactionManagerLookup

        public TransactionManagerLookup getTransactionManagerLookup()
        Get the TransactionManagerLookup implementation used to lookup the TransactionManager. This is generally only set for XA transactional caches
        Returns:
        The TransactionManagerLookup instance

      • initialise

        public void initialise()
        Newly created caches do not have a Store.

        This method creates the store and makes the cache ready to accept elements

        Specified by:
        initialise in interface Ehcache

      • getWriterManager

        public CacheWriterManager getWriterManager()
        Obtain the writer manager that's used by this cache instance.
        Specified by:
        getWriterManager in interface Ehcache
        Returns:
        the writer manager that's set up for this cache

      • createDiskStore

        protected DiskStore createDiskStore()
        Creates a disk store when either:
        1. overflowToDisk is enabled
        2. diskPersistent is enabled
        Returns:
        the disk store

      • isDiskStore

        protected boolean isDiskStore()
        Whether this cache uses a disk store
        Returns:
        true if the cache either overflows to disk or uses a local-classic persistence strategy.

      • isTerracottaClustered

        public boolean isTerracottaClustered()
        Indicates whether this cache is clustered by Terracotta
        Returns:
        true when the cache is clustered by Terracotta; or false otherwise

      • bootstrap

        public void bootstrap()
        Bootstrap command. This must be called after the Cache is initialised, during CacheManager initialisation. If loads are synchronous, they will complete before the CacheManager initialise completes, otherwise they will happen in the background.
        Specified by:
        bootstrap in interface Ehcache

      • put

        public final void put​(Element element)
               throws java.lang.IllegalArgumentException,
                      java.lang.IllegalStateException,
                      CacheException
        Put an element in the cache.

        Resets the access statistics on the element, which would be the case if it has previously been gotten from a cache, and is now being put back.

        Also notifies the CacheEventListener that:

        • the element was put, but only if the Element was actually put.
        • if the element exists in the cache, that an update has occurred, even if the element would be expired if it was requested
        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.
        Specified by:
        put in interface Ehcache
        Parameters:
        element - A cache Element. If Serializable it can fully participate in replication and the DiskStore. If it is null or the key is null, it is ignored as a NOOP.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException - in case of error
        java.lang.IllegalArgumentException - if the element is null

      • putAll

        public void putAll​(java.util.Collection<Element> elements)
            throws java.lang.IllegalArgumentException,
                   java.lang.IllegalStateException,
                   CacheException
        Puts a collection of elements in to the cache.

        This method will throw a NullPointerException if a null element or null key is encountered in the collection, and a partial completion may result (as only some of the elements may have been put).

        For each element that is put the registered CacheEventListeners are notified of a newly put item (notifyElementPut(...)) regardless of whether the individual put is a new put or an update.

        Specified by:
        putAll in interface Ehcache
        Parameters:
        elements - the collection of elements to be put in the cache.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException - a runtime cache exception
        java.lang.IllegalArgumentException

      • put

        public final void put​(Element element,
                      boolean doNotNotifyCacheReplicators)
               throws java.lang.IllegalArgumentException,
                      java.lang.IllegalStateException,
                      CacheException
        Put an element in the cache.

        Resets the access statistics on the element, which would be the case if it has previously been gotten from a cache, and is now being put back.

        Also notifies the CacheEventListener that:

        • the element was put, but only if the Element was actually put.
        • if the element exists in the cache, that an update has occurred, even if the element would be expired if it was requested
        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.
        Specified by:
        put in interface Ehcache
        Parameters:
        element - A cache Element. If Serializable it can fully participate in replication and the DiskStore. If it is null or the key is null, it is ignored as a NOOP.
        doNotNotifyCacheReplicators - whether the put is coming from a doNotNotifyCacheReplicators cache peer, in which case this put should not initiate a further notification to doNotNotifyCacheReplicators cache peers
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        java.lang.IllegalArgumentException - if the element is null
        CacheException

      • putWithWriter

        public void putWithWriter​(Element element)
                   throws java.lang.IllegalArgumentException,
                          java.lang.IllegalStateException,
                          CacheException
        Put an element in the cache writing through a CacheWriter. If no CacheWriter has been registered for the cache, then this method throws an exception.

        Resets the access statistics on the element, which would be the case if it has previously been gotten from a cache, and is now being put back.

        Also notifies the CacheEventListener, if the writer operation succeeds, that:

        • the element was put, but only if the Element was actually put.
        • if the element exists in the cache, that an update has occurred, even if the element would be expired if it was requested
        Specified by:
        putWithWriter in interface Ehcache
        Parameters:
        element - An object. If Serializable it can fully participate in replication and the DiskStore.
        Throws:
        java.lang.IllegalArgumentException - if the element is null
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException - if no CacheWriter was registered

      • putQuiet

        public final void putQuiet​(Element element)
                    throws java.lang.IllegalArgumentException,
                           java.lang.IllegalStateException,
                           CacheException
        Put an element in the cache, without updating statistics, or updating listeners. This is meant to be used in conjunction with getQuiet(java.io.Serializable). Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        putQuiet in interface Ehcache
        Parameters:
        element - A cache Element. If Serializable it can fully participate in replication and the DiskStore. If it is null or the key is null, it is ignored as a NOOP.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        java.lang.IllegalArgumentException - if the element is null
        CacheException

      • get

        public final Element get​(java.io.Serializable key)
                  throws java.lang.IllegalStateException,
                         CacheException
        Gets an element from the cache. Updates Element Statistics

        Note that the Element's lastAccessTime is always the time of this get. Use getQuiet(Object) to peak into the Element to see its last access time with get

        Synchronization is handled within the method.

        Specified by:
        get in interface Ehcache
        Parameters:
        key - a serializable value. Null keys are not stored so get(null) always returns null
        Returns:
        the element, or null, if it does not exist.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException
        See Also:
        isExpired(net.sf.ehcache.Element)

      • get

        public final Element get​(java.lang.Object key)
                  throws java.lang.IllegalStateException,
                         CacheException
        Gets an element from the cache. Updates Element Statistics

        Note that the Element's lastAccessTime is always the time of this get. Use getQuiet(Object) to peak into the Element to see its last access time with get

        Synchronization is handled within the method.

        Specified by:
        get in interface Ehcache
        Parameters:
        key - an Object value
        Returns:
        the element, or null, if it does not exist.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException
        Since:
        1.2
        See Also:
        isExpired(net.sf.ehcache.Element)

      • getAll

        public java.util.Map<java.lang.Object,​Element> getAll​(java.util.Collection<?> keys)
                                                     throws java.lang.IllegalStateException,
                                                            CacheException
        Gets all the elements from the cache for the keys provided. Updates Element Statistics Throws a NullPointerException if any key in the collection is null

        Note that the Element's lastAccessTime is always the time of this get. Use Ehcache.getQuiet(Object) to peek into the Element to see its last access time with get

        Specified by:
        getAll in interface Ehcache
        Parameters:
        keys - a collection of keys for which value is to be fetched
        Returns:
        Map of key and elements for the provided keys, value will be null for the keys which do not exist
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException
        See Also:
        Ehcache.isExpired(net.sf.ehcache.Element)

      • getWithLoader

        public Element getWithLoader​(java.lang.Object key,
                             CacheLoader loader,
                             java.lang.Object loaderArgument)
                      throws CacheException
        This method will return, from the cache, the Element associated with the argument "key".

        If the Element is not in the cache, the associated cache loader will be called. That is either the CacheLoader passed in, or if null, the one associated with the cache. If both are null, no load is performed and null is returned.

        Because this method may take a long time to complete, it is not synchronized. The underlying cache operations are synchronized.

        Specified by:
        getWithLoader in interface Ehcache
        Parameters:
        key - key whose associated value is to be returned.
        loader - the override loader to use. If null, the cache's default loader will be used
        loaderArgument - an argument to pass to the CacheLoader.
        Returns:
        an element if it existed or could be loaded, otherwise null
        Throws:
        CacheException - if the loading fails

      • load

        public void load​(java.lang.Object key)
          throws CacheException
        The load method provides a means to "pre-load" the cache. This method will, asynchronously, load the specified object into the cache using the associated CacheLoader. If the object already exists in the cache, no action is taken. If no loader is associated with the object, no object will be loaded into the cache. If a problem is encountered during the retrieving or loading of the object, an exception should be logged. If the "arg" argument is set, the arg object will be passed to the CacheLoader.load method. The cache will not dereference the object. If no "arg" value is provided a null will be passed to the load method. The storing of null values in the cache is permitted, however, the get method will not distinguish returning a null stored in the cache and not finding the object in the cache. In both cases a null is returned.

        The Ehcache native API provides similar functionality to loaders using the decorator SelfPopulatingCache

        Specified by:
        load in interface Ehcache
        Parameters:
        key - key whose associated value to be loaded using the associated CacheLoader if this cache doesn't contain it.
        Throws:
        CacheException - in case of error

      • getAllWithLoader

        public java.util.Map getAllWithLoader​(java.util.Collection keys,
                                      java.lang.Object loaderArgument)
                               throws CacheException
        The getAll method will return, from the cache, a Map of the objects associated with the Collection of keys in argument "keys". If the objects are not in the cache, the associated cache loader will be called. If no loader is associated with an object, a null is returned. If a problem is encountered during the retrieving or loading of the objects, an exception will be thrown. If the "arg" argument is set, the arg object will be passed to the CacheLoader.loadAll method. The cache will not dereference the object. If no "arg" value is provided a null will be passed to the loadAll method. The storing of null values in the cache is permitted, however, the get method will not distinguish returning a null stored in the cache and not finding the object in the cache. In both cases a null is returned.

        Note. If the getAll exceeds the maximum cache size, the returned map will necessarily be less than the number specified.

        Because this method may take a long time to complete, it is not synchronized. The underlying cache operations are synchronized.

        The constructs package provides similar functionality using the decorator SelfPopulatingCache

        Specified by:
        getAllWithLoader in interface Ehcache
        Parameters:
        keys - a collection of keys to be returned/loaded
        loaderArgument - an argument to pass to the CacheLoader.
        Returns:
        a Map populated from the Cache. If there are no elements, an empty Map is returned.
        Throws:
        CacheException - in case of error

      • loadAll

        public void loadAll​(java.util.Collection keys,
                    java.lang.Object argument)
             throws CacheException
        The loadAll method provides a means to "pre load" objects into the cache. This method will, asynchronously, load the specified objects into the cache using the associated cache loader(s). If the an object already exists in the cache, no action is taken. If no loader is associated with the object, no object will be loaded into the cache. If a problem is encountered during the retrieving or loading of the objects, an exception (to be defined) should be logged. The getAll method will return, from the cache, a Map of the objects associated with the Collection of keys in argument "keys". If the objects are not in the cache, the associated cache loader will be called. If no loader is associated with an object, a null is returned. If a problem is encountered during the retrieving or loading of the objects, an exception (to be defined) will be thrown. If the "arg" argument is set, the arg object will be passed to the CacheLoader.loadAll method. The cache will not dereference the object. If no "arg" value is provided a null will be passed to the loadAll method.

        keys - collection of the keys whose associated values to be loaded into this cache by using the associated CacheLoader if this cache doesn't contain them.

        The Ehcache native API provides similar functionality to loaders using the decorator SelfPopulatingCache

        Specified by:
        loadAll in interface Ehcache
        Parameters:
        keys - - collection of the keys whose associated values to be loaded into this cache by using the associated cacheloader if this cache doesn't contain them.
        argument - can be anything that makes sense to the loader

        The Ehcache native API provides similar functionality to loaders using the decorator SelfPopulatingCache

        Throws:
        CacheException

      • getQuiet

        public final Element getQuiet​(java.io.Serializable key)
                       throws java.lang.IllegalStateException,
                              CacheException
        Gets an element from the cache, without updating Element statistics. Cache statistics are still updated. Listeners are not called.
        Specified by:
        getQuiet in interface Ehcache
        Parameters:
        key - a serializable value
        Returns:
        the element, or null, if it does not exist.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException
        See Also:
        isExpired(net.sf.ehcache.Element)

      • getQuiet

        public final Element getQuiet​(java.lang.Object key)
                       throws java.lang.IllegalStateException,
                              CacheException
        Gets an element from the cache, without updating Element statistics. Cache statistics are not updated.

        Listeners are not called.

        Specified by:
        getQuiet in interface Ehcache
        Parameters:
        key - a serializable value
        Returns:
        the element, or null, if it does not exist.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException
        Since:
        1.2
        See Also:
        isExpired(net.sf.ehcache.Element)

      • getKeys

        public final java.util.List getKeys()
                             throws java.lang.IllegalStateException,
                                    CacheException
        Returns a list of all element keys in the cache, whether or not they are expired.

        The returned keys are unique and can almost be considered a set. See CacheKeySet for more details.

        The List returned is not live. It is a copy.

        The time taken is O(n). For large caches - or caches with high-latency storage this method can take a very long time to complete, may cause timeouts if using features such NonStopCache or transactions, and is not guaranteed to give a consistent view of the cache entry set. Usage is highly discouraged.

        Specified by:
        getKeys in interface Ehcache
        Returns:
        a list of Object keys
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException
        See Also:
        CacheKeySet

      • getKeysWithExpiryCheck

        public final java.util.List getKeysWithExpiryCheck()
                                            throws java.lang.IllegalStateException,
                                                   CacheException
        Returns a list of all element keys in the cache. Only keys of non-expired elements are returned.

        The returned keys are unique and can be considered a set.

        The List returned is not live. It is a copy.

        The time taken is O(n), where n is the number of elements in the cache. On a 1.8Ghz P4, the time taken is approximately 200ms per 1000 entries. This method is not synchronized, because it relies on a non-live list returned from getKeys() , which is synchronised, and which takes 8ms per 1000 entries. This way cache liveness is preserved, even if this method is very slow to return.

        Consider whether your usage requires checking for expired keys. Because this method takes so long, depending on cache settings, the list could be quite out of date by the time you get it.

        Specified by:
        getKeysWithExpiryCheck in interface Ehcache
        Returns:
        a list of Object keys
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • getKeysNoDuplicateCheck

        public final java.util.List getKeysNoDuplicateCheck()
                                             throws java.lang.IllegalStateException
        Returns a list of all elements in the cache, whether or not they are expired.

        The returned keys are not unique and may contain duplicates. If the cache is only using the memory store, the list will be unique. If the disk store is being used as well, it will likely contain duplicates, because of the internal store design.

        The List returned is not live. It is a copy.

        The time taken is O(log n). On a single CPU 1.8Ghz P4, approximately 6ms is required for 1000 entries and 36 for 50000.

        This is the fastest getKeys method

        Specified by:
        getKeysNoDuplicateCheck in interface Ehcache
        Returns:
        a list of Object keys
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • remove

        public final boolean remove​(java.io.Serializable key)
                     throws java.lang.IllegalStateException
        Removes an Element from the Cache. This also removes it from any stores it may be in.

        Also notifies the CacheEventListener after the element was removed.

        Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        remove in interface Ehcache
        Parameters:
        key - the element key to operate on
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • remove

        public final boolean remove​(java.lang.Object key)
                     throws java.lang.IllegalStateException
        Removes an Element from the Cache. This also removes it from any stores it may be in.

        Also notifies the CacheEventListener after the element was removed, but only if an Element with the key actually existed.

        Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        remove in interface Ehcache
        Parameters:
        key - the element key to operate on
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        Since:
        1.2

      • removeAndReturnElement

        public final Element removeAndReturnElement​(java.lang.Object key)
                                     throws java.lang.IllegalStateException
        Removes an Element from the Cache and returns it. This also removes it from any stores it may be in.

        Also notifies the CacheEventListener after the element was removed, but only if an Element with the key actually existed.

        Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        removeAndReturnElement in interface InternalEhcache
        Parameters:
        key - the element key to operate on
        Returns:
        element the removed element associated with the key, null if no mapping exists
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • removeAll

        public void removeAll​(java.util.Collection<?> keys)
               throws java.lang.IllegalStateException
        Removes given set of Element from the Cache. This also removes them from any stores it may be in. Throws a NullPointerException if any key in the collection is null

        Also notifies the CacheEventListener after the elements were removed. Notification is sent for every key irrespective of whether the key was present in the cache or not This operation is partially completed if any element or any key is null

        Specified by:
        removeAll in interface Ehcache
        Parameters:
        keys - a collection of keys to operate on
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • removeAll

        public final void removeAll​(java.util.Collection<?> keys,
                            boolean doNotNotifyCacheReplicators)
                     throws java.lang.IllegalStateException
        Removes all cached items.

        When using Terracotta clustered caches with nonstop enabled, the timeout used by this method is NonstopConfiguration.getBulkOpsTimeoutMultiplyFactor() times the timeout value in the nonstop config.

        Specified by:
        removeAll in interface Ehcache
        Parameters:
        keys - a collection of keys to operate on
        doNotNotifyCacheReplicators - whether the put is coming from a doNotNotifyCacheReplicators cache peer, in which case this put should not initiate a further notification to doNotNotifyCacheReplicators cache peers
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • remove

        public final boolean remove​(java.io.Serializable key,
                            boolean doNotNotifyCacheReplicators)
                     throws java.lang.IllegalStateException
        Removes an Element from the Cache. This also removes it from any stores it may be in.

        Also notifies the CacheEventListener after the element was removed, but only if an Element with the key actually existed.

        Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        remove in interface Ehcache
        Parameters:
        key - the element key to operate on
        doNotNotifyCacheReplicators - whether the remove is coming from a doNotNotifyCacheReplicators cache peer, in which case this remove should not initiate a further notification to doNotNotifyCacheReplicators cache peers
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • remove

        public final boolean remove​(java.lang.Object key,
                            boolean doNotNotifyCacheReplicators)
                     throws java.lang.IllegalStateException
        Removes an Element from the Cache. This also removes it from any stores it may be in.

        Also notifies the CacheEventListener after the element was removed, but only if an Element with the key actually existed.

        Synchronization is handled within the method.

        Specified by:
        remove in interface Ehcache
        Parameters:
        key - the element key to operate on
        doNotNotifyCacheReplicators - whether the remove is coming from a doNotNotifyCacheReplicators cache peer, in which case this remove should not initiate a further notification to doNotNotifyCacheReplicators cache peers
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • removeQuiet

        public final boolean removeQuiet​(java.io.Serializable key)
                          throws java.lang.IllegalStateException
        Removes an Element from the Cache, without notifying listeners. This also removes it from any stores it may be in.

        Listeners are not called.

        Specified by:
        removeQuiet in interface Ehcache
        Parameters:
        key - the element key to operate on
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • removeQuiet

        public final boolean removeQuiet​(java.lang.Object key)
                          throws java.lang.IllegalStateException
        Removes an Element from the Cache, without notifying listeners. This also removes it from any stores it may be in.

        Listeners are not called.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        removeQuiet in interface Ehcache
        Parameters:
        key - the element key to operate on
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        Since:
        1.2

      • removeWithWriter

        public boolean removeWithWriter​(java.lang.Object key)
                         throws java.lang.IllegalStateException
        Removes an Element from the Cache and any stores it might be in. This also removes through to a CacheWriter. If no CacheWriter has been registered for the cache, then this method throws an exception.

        Also notifies the CacheEventListener after the element was removed, but only if an Element with the key actually existed.

        Specified by:
        removeWithWriter in interface Ehcache
        Parameters:
        key - of the element to remove
        Returns:
        true if the element was removed, false if it was not found in the cache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • removeAll

        public void removeAll()
               throws java.lang.IllegalStateException,
                      CacheException
        Removes all cached items. Terracotta clustered caches may require more time to execute this operation because cached items must also be removed from the Terracotta Server Array. Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        removeAll in interface Ehcache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • removeAll

        public void removeAll​(boolean doNotNotifyCacheReplicators)
               throws java.lang.IllegalStateException,
                      CacheException
        Removes all cached items. Synchronization is handled within the method.

        Caches which use synchronous replication can throw RemoteCacheException here if the replication to the cluster fails. This exception should be caught in those circumstances.

        Specified by:
        removeAll in interface Ehcache
        Parameters:
        doNotNotifyCacheReplicators - whether the put is coming from a doNotNotifyCacheReplicators cache peer, in which case this put should not initiate a further notification to doNotNotifyCacheReplicators cache peers
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • dispose

        public void dispose()
             throws java.lang.IllegalStateException
        Starts an orderly shutdown of the Cache. Steps are:
        1. Completes any outstanding CacheLoader loads.
        2. Completes any outstanding CacheWriter operations.
        3. Disposes any cache extensions.
        4. Disposes any cache event listeners. The listeners normally complete, so for example distributed caching operations will complete.
        5. Flushes all cache items from memory to the disk store, if any
        6. changes status to shutdown, so that any cache operations after this point throw IllegalStateException
        This method should be invoked only by CacheManager, as a cache's lifecycle is bound into that of it's cache manager.
        Specified by:
        dispose in interface Ehcache
        Throws:
        java.lang.IllegalStateException - if the cache is already Status.STATUS_SHUTDOWN

      • getCacheConfiguration

        public CacheConfiguration getCacheConfiguration()
        Gets the cache configuration this cache was created with.

        Things like listeners that are added dynamically are excluded.

        Specified by:
        getCacheConfiguration in interface Ehcache
        Returns:
        CacheConfiguration the cache configuration

      • flush

        public final void flush()
                 throws java.lang.IllegalStateException,
                        CacheException
        Flushes all cache items from memory to the disk store, and from the DiskStore to disk.
        Specified by:
        flush in interface Ehcache
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • getSize

        public final int getSize()
                  throws java.lang.IllegalStateException,
                         CacheException
        Gets the size of the cache. This is a subtle concept. See below.

        This number is the actual number of elements, including expired elements that have not been removed.

        Expired elements are removed from the the memory store when getting an expired element, or when attempting to spool an expired element to disk.

        Expired elements are removed from the disk store when getting an expired element, or when the expiry thread runs, which is once every five minutes.

        To get an exact size, which would exclude expired elements, use getKeysWithExpiryCheck().size(), although see that method for the approximate time that would take.

        To get a very fast result, use getKeysNoDuplicateCheck().size(). If the disk store is being used, there will be some duplicates.

        Note:getSize() is a very expensive operation in off-heap, disk and Terracotta implementations.

        Specified by:
        getSize in interface Ehcache
        Returns:
        The size value
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • calculateInMemorySize

        @Deprecated
public final long calculateInMemorySize()
                                 throws java.lang.IllegalStateException,
                                        CacheException
        Deprecated.
        Gets the size of the memory store for this cache. This method relies on calculating Serialized sizes. If the Element values are not Serializable they will show as zero.

        Warning: This method can be very expensive to run. Allow approximately 1 second per 1MB of entries. Running this method could create liveness problems because the object lock is held for a long period

        Specified by:
        calculateInMemorySize in interface Ehcache
        Returns:
        the approximate size of the memory store in bytes
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • hasAbortedSizeOf

        public boolean hasAbortedSizeOf()
        Check if the cache may contain elements which the SizeOf engine could not fully size.
        Specified by:
        hasAbortedSizeOf in interface Ehcache
        Returns:
        true if the cache may contain partially sized objects

      • calculateOffHeapSize

        @Deprecated
public final long calculateOffHeapSize()
                                throws java.lang.IllegalStateException,
                                       CacheException
        Deprecated.
        Gets the size of the off-heap store for this cache.
        Specified by:
        calculateOffHeapSize in interface Ehcache
        Returns:
        the size of the off-heap store in bytes
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • calculateOnDiskSize

        @Deprecated
public final long calculateOnDiskSize()
                               throws java.lang.IllegalStateException,
                                      CacheException
        Deprecated.
        Gets the size of the on-disk store for this cache
        Specified by:
        calculateOnDiskSize in interface Ehcache
        Returns:
        the size of the on-disk store in bytes
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        CacheException

      • getMemoryStoreSize

        @Deprecated
public final long getMemoryStoreSize()
                              throws java.lang.IllegalStateException
        Deprecated.
        Returns the number of elements in the memory store.
        Specified by:
        getMemoryStoreSize in interface Ehcache
        Returns:
        the number of elements in the memory store
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • getOffHeapStoreSize

        @Deprecated
public long getOffHeapStoreSize()
                         throws java.lang.IllegalStateException
        Deprecated.
        Returns the number of elements in the off-heap store.
        Specified by:
        getOffHeapStoreSize in interface Ehcache
        Returns:
        the number of elements in the off-heap store
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • getDiskStoreSize

        @Deprecated
public final int getDiskStoreSize()
                           throws java.lang.IllegalStateException
        Deprecated.
        Returns the number of elements in the disk store.
        Specified by:
        getDiskStoreSize in interface Ehcache
        Returns:
        the number of elements in the disk store.
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • getStatus

        public final Status getStatus()
        Gets the status attribute of the Cache.
        Specified by:
        getStatus in interface Ehcache
        Returns:
        The status value from the Status enum class

      • getName

        public final java.lang.String getName()
        Gets the cache name.
        Specified by:
        getName in interface Ehcache
        Returns:
        the name

      • setName

        public final void setName​(java.lang.String name)
                   throws java.lang.IllegalArgumentException
        Sets the cache name which will name.
        Specified by:
        setName in interface Ehcache
        Parameters:
        name - the name of the cache. Should not be null. Should also not contain any '/' characters, as these interfere with distribution
        Throws:
        java.lang.IllegalArgumentException - if an illegal name is used.

      • toString

        public java.lang.String toString()
        Returns a String representation of Cache.
        Specified by:
        toString in interface Ehcache
        Overrides:
        toString in class java.lang.Object

      • isExpired

        public final boolean isExpired​(Element element)
                        throws java.lang.IllegalStateException,
                               java.lang.NullPointerException
        Checks whether this cache element has expired.

        The element is expired if:

        1. the idle time is non-zero and has elapsed, unless the cache is eternal; or
        2. the time to live is non-zero and has elapsed, unless the cache is eternal; or
        3. the value of the element is null.
        Specified by:
        isExpired in interface Ehcache
        Parameters:
        element - the element to check
        Returns:
        true if it has expired
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE
        java.lang.NullPointerException - if the element is null todo this does not need to be synchronized

      • clone

        public final Cache clone()
                  throws java.lang.CloneNotSupportedException
        Clones a cache. This is only legal if the cache has not been initialized. At that point only primitives have been set and no stores have been created.

        A new, empty, RegisteredEventListeners is created on clone.

        Specified by:
        clone in interface Ehcache
        Overrides:
        clone in class java.lang.Object
        Returns:
        an object of type Cache
        Throws:
        java.lang.CloneNotSupportedException - when it's not supported

      • getStoreMBean

        public final java.lang.Object getStoreMBean()
        Get the optional store management bean for this cache.
        Returns:
        the store MBean

      • getCacheEventNotificationService

        public final RegisteredEventListeners getCacheEventNotificationService()
        Use this to access the service in order to register and unregister listeners
        Specified by:
        getCacheEventNotificationService in interface Ehcache
        Returns:
        the RegisteredEventListeners instance for this cache.

      • isElementInMemory

        public final boolean isElementInMemory​(java.io.Serializable key)
        Whether an Element is stored in the cache in Memory, indicating a very low cost of retrieval.

        Since no assertions are made about the state of the Element it is possible that the Element is expired, but this method still returns true.

        Specified by:
        isElementInMemory in interface Ehcache
        Parameters:
        key - the key of the element to remove
        Returns:
        true if an element matching the key is found in memory

      • isElementInMemory

        public final boolean isElementInMemory​(java.lang.Object key)
        Whether an Element is stored in the cache in Memory, indicating a very low cost of retrieval.

        Since no assertions are made about the state of the Element it is possible that the Element is expired, but this method still returns true.

        Specified by:
        isElementInMemory in interface Ehcache
        Parameters:
        key - the key of the element to remove
        Returns:
        true if an element matching the key is found in memory
        Since:
        1.2

      • isElementOffHeap

        public final boolean isElementOffHeap​(java.lang.Object key)
        Whether an Element is stored in the cache in off-heap memory, indicating an intermediate cost of retrieval.

        Since no assertions are made about the state of the Element it is possible that the Element is expired, but this method still returns true.

        Parameters:
        key - key to look for
        Returns:
        true if an element matching the key is found in off-heap
        Since:
        2.3

      • isElementOnDisk

        public final boolean isElementOnDisk​(java.io.Serializable key)
        Whether an Element is stored in the cache on Disk, indicating a higher cost of retrieval.

        Since no assertions are made about the state of the Element it is possible that the Element is expired, but this method still returns true.

        Specified by:
        isElementOnDisk in interface Ehcache
        Parameters:
        key - key to look for
        Returns:
        true if an element matching the key is found in the diskStore

      • isElementOnDisk

        public final boolean isElementOnDisk​(java.lang.Object key)
        Whether an Element is stored in the cache on Disk, indicating a higher cost of retrieval.

        Since no assertions are made about the state of the Element it is possible that the Element is expired, but this method still returns true.

        Specified by:
        isElementOnDisk in interface Ehcache
        Parameters:
        key - key to look for
        Returns:
        true if an element matching the key is found in the diskStore
        Since:
        1.2

      • getGuid

        public final java.lang.String getGuid()
        The GUID for this cache instance can be used to determine whether two cache instance references are pointing to the same cache.
        Specified by:
        getGuid in interface Ehcache
        Returns:
        the globally unique identifier for this cache instance. This is guaranteed to be unique.
        Since:
        1.2

      • getCacheManager

        public final CacheManager getCacheManager()
        Gets the CacheManager managing this cache. For a newly created cache this will be null until it has been added to a CacheManager.
        Specified by:
        getCacheManager in interface Ehcache
        Returns:
        the manager or null if there is none

      • evictExpiredElements

        public void evictExpiredElements()
        Causes all elements stored in the Cache to be synchronously checked for expiry, and if expired, evicted.
        Specified by:
        evictExpiredElements in interface Ehcache

      • isKeyInCache

        public boolean isKeyInCache​(java.lang.Object key)
        An inexpensive check to see if the key exists in the cache.

        This method is not synchronized. It is possible that an element may exist in the cache and be removed before the check gets to it, or vice versa. Since no assertions are made about the state of the Element it is possible that the Element is expired, but this method still returns true.

        Specified by:
        isKeyInCache in interface Ehcache
        Parameters:
        key - the key to check.
        Returns:
        true if an Element matching the key is found in the cache. No assertions are made about the state of the Element.

      • isValueInCache

        public boolean isValueInCache​(java.lang.Object value)
        An extremely expensive check to see if the value exists in the cache. This implementation is O(n). Ehcache is not designed for efficient access in this manner.

        This method is not synchronized. It is possible that an element may exist in the cache and be removed before the check gets to it, or vice versa. Because it is slow to execute the probability of that this will have happened.

        Specified by:
        isValueInCache in interface Ehcache
        Parameters:
        value - to check for
        Returns:
        true if an Element matching the key is found in the cache. No assertions are made about the state of the Element.

      • getStatistics

        public StatisticsGateway getStatistics()
                                throws java.lang.IllegalStateException
        Gets an immutable Statistics object representing the Cache statistics at the time.

        Note, the getSize() method will have the same value as the size reported by Statistics for the statistics accuracy of

        Specified by:
        getStatistics in interface Ehcache
        Returns:
        the statistics gateway
        Throws:
        java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

      • setCacheManager

        public void setCacheManager​(CacheManager cacheManager)
        For use by CacheManager.
        Specified by:
        setCacheManager in interface Ehcache
        Parameters:
        cacheManager - the CacheManager for this cache to use.

      • getBootstrapCacheLoader

        public BootstrapCacheLoader getBootstrapCacheLoader()
        Accessor for the BootstrapCacheLoader associated with this cache. For testing purposes.
        Specified by:
        getBootstrapCacheLoader in interface Ehcache
        Returns:
        the BootstrapCacheLoader to use

      • equals

        public boolean equals​(java.lang.Object object)
        An equals method which follows the contract of Object.equals(Object)

        An Cache is equal to another one if it implements Ehcache and has the same GUID.

        Overrides:
        equals in class java.lang.Object
        Parameters:
        object - the reference object with which to compare.
        Returns:
        true if this object is the same as the obj argument; false otherwise.
        See Also:
        hashCode(), Hashtable

      • hashCode

        public int hashCode()
        Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those provided by java.util.Hashtable.

        The general contract of hashCode is:

        • Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
        • If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
        • It is not required that if two objects are unequal according to the Object.equals(Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

        As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java(TM) programming language.)

        This implementation use the GUID of the cache.

        Overrides:
        hashCode in class java.lang.Object
        Returns:
        a hash code value for this object.
        See Also:
        Object.equals(Object), Hashtable

      • registerCacheExtension

        public void registerCacheExtension​(CacheExtension cacheExtension)
        Register a CacheExtension with the cache. It will then be tied into the cache lifecycle.

        If the CacheExtension is not initialised, initialise it.

        Specified by:
        registerCacheExtension in interface Ehcache
        Parameters:
        cacheExtension - the cache extension

      • unregisterCacheExtension

        public void unregisterCacheExtension​(CacheExtension cacheExtension)
        Unregister a CacheExtension with the cache. It will then be detached from the cache lifecycle.
        Specified by:
        unregisterCacheExtension in interface Ehcache
        Parameters:
        cacheExtension - the cache extension

      • registerCacheLoader

        public void registerCacheLoader​(CacheLoader cacheLoader)
        Register a CacheLoader with the cache. It will then be tied into the cache lifecycle.

        The CacheLoader instance will be initialized when the cache itself is being initialized. Should the cache already be initialized, CacheLoader.init() will not be invoked. If the loader requires initialization, the user will have to call it manually before registering it with a Cache instance that's already alive

        Specified by:
        registerCacheLoader in interface Ehcache
        Parameters:
        cacheLoader - A Cache Loader to register

      • unregisterCacheLoader

        public void unregisterCacheLoader​(CacheLoader cacheLoader)
        Unregister a CacheLoader with the cache. It will then be detached from the cache lifecycle.
        Specified by:
        unregisterCacheLoader in interface Ehcache
        Parameters:
        cacheLoader - A Cache Loader to unregister

      • registerCacheWriter

        public void registerCacheWriter​(CacheWriter cacheWriter)
        Register the CacheWriter for this cache. It will then be tied into the cache lifecycle.

        If the CacheWriter is not initialised, initialise it.

        Specified by:
        registerCacheWriter in interface Ehcache
        Parameters:
        cacheWriter - A CacheWriter to register

      • unregisterCacheWriter

        public void unregisterCacheWriter()
        Unregister the CacheWriter from the cache. It will then be detached from the cache lifecycle.

        If not CacheWriter was registered beforehand this operation has no effect.

        Specified by:
        unregisterCacheWriter in interface Ehcache

      • getRegisteredCacheWriter

        public CacheWriter getRegisteredCacheWriter()
        Retrieves the CacheWriter that was registered for this cache.
        Specified by:
        getRegisteredCacheWriter in interface Ehcache
        Returns:
        the registered CacheWriter; or null if none was registered before

      • registerDynamicAttributesExtractor

        public void registerDynamicAttributesExtractor​(DynamicAttributesExtractor extractor)
        Allows user to register a dynamic attribute extractor with a searchable cache that is dynamically indexable, as indicated by its configuration. Calling this method on such a cache is optional, but doing so more than once replaces previously registered extractor with the given one; i.e., there can be at most one extractor instance configured for each such cache. If the cache was not configured for dynamic indexing, an exception will be thrown
        Specified by:
        registerDynamicAttributesExtractor in interface Ehcache
        Parameters:
        extractor - the dynamic attribute extractor

      • isDisabled

        public boolean isDisabled()
        Whether this cache is disabled. "Disabled" means:
        1. bootstrap is disabled
        2. puts are discarded
        3. putQuiets are discarded
        4. gets return null
        In all other respects the cache continues as it is.

        You can disable and enable a cache programmatically through the setDisabled(boolean) method.

        By default caches are enabled on creation, unless the net.sf.ehcache.disabled system property is set.

        Specified by:
        isDisabled in interface Ehcache
        Returns:
        true if the cache is disabled.
        See Also:
        ?

      • setDisabled

        public void setDisabled​(boolean disabled)
        Disables or enables this cache. This call overrides the previous value of disabled, even if the net.sf.ehcache.disabled system property is set
        Specified by:
        setDisabled in interface Ehcache
        Parameters:
        disabled - true if you wish to disable, false to enable
        See Also:
        isDisabled()

      • getMemoryStoreEvictionPolicy

        public Policy getMemoryStoreEvictionPolicy()
        Returns:
        the current in-memory eviction policy. This may not be the configured policy, if it has been dynamically set.

      • setMemoryStoreEvictionPolicy

        public void setMemoryStoreEvictionPolicy​(Policy policy)
        Sets the eviction policy strategy. The Cache will use a policy at startup. There are three policies which can be configured: LRU, LFU and FIFO. However many other policies are possible. That the policy has access to the whole element enables policies based on the key, value, metadata, statistics, or a combination of any of the above. It is safe to change the policy of a store at any time. The new policy takes effect immediately.
        Parameters:
        policy - the new policy

      • getInternalContext

        public java.lang.Object getInternalContext()
        This should not be used
        Specified by:
        getInternalContext in interface Ehcache
        Returns:
        some internal context (generally will be null)

      • disableDynamicFeatures

        public void disableDynamicFeatures()
        Disables dynamic configuration and disable/enable for this cache.

        This is a one time operation. Once an Ehcache instance has had its dynamic operations disabled they cannot be re-enabled.

        Specified by:
        disableDynamicFeatures in interface Ehcache

      • isClusterCoherent

        @Deprecated
public boolean isClusterCoherent()
        Deprecated.
        use isClusterBulkLoadEnabled() instead
        Returns true if the cache is in coherent mode cluster-wide. Returns false otherwise.

        It applies to coherent clustering mechanisms only e.g. Terracotta

        Specified by:
        isClusterCoherent in interface Ehcache
        Returns:
        true if the cache is in coherent mode cluster-wide, false otherwise

      • isNodeCoherent

        @Deprecated
public boolean isNodeCoherent()
        Deprecated.
        use isNodeBulkLoadEnabled() instead
        Returns true if the cache is in coherent mode for the current node. Returns false otherwise.

        It applies to coherent clustering mechanisms only e.g. Terracotta

        Specified by:
        isNodeCoherent in interface Ehcache
        Returns:
        true if the cache is in coherent mode cluster-wide, false otherwise

      • setNodeCoherent

        @Deprecated
public void setNodeCoherent​(boolean coherent)
        Deprecated.
        use setNodeBulkLoadEnabled(boolean) instead
        Sets the cache in coherent or incoherent mode depending on the parameter on this node. Calling setNodeCoherent(true) when the cache is already in coherent mode or calling setNodeCoherent(false) when already in incoherent mode will be a no-op.

        It applies to coherent clustering mechanisms only e.g. Terracotta

        When using Terracotta clustered caches with nonstop enabled, the timeout used by this method is NonstopConfiguration.getBulkOpsTimeoutMultiplyFactor() times the timeout value in the config.

        Specified by:
        setNodeCoherent in interface Ehcache
        Parameters:
        coherent - true transitions to coherent mode, false to incoherent mode

      • waitUntilClusterCoherent

        @Deprecated
public void waitUntilClusterCoherent()
        Deprecated.
        use waitUntilClusterBulkLoadComplete() instead
        This method waits until the cache is in coherent mode in all the connected nodes. If the cache is already in coherent mode it returns immediately

        It applies to coherent clustering mechanisms only e.g. Terracotta

        Specified by:
        waitUntilClusterCoherent in interface Ehcache

      • addPropertyChangeListener

        public void addPropertyChangeListener​(java.beans.PropertyChangeListener listener)
        Description copied from interface: Ehcache
        Add a PropertyChangeListener.
        Specified by:
        addPropertyChangeListener in interface Ehcache
        Parameters:
        listener - the PropertyChangeListener to add

      • removePropertyChangeListener

        public void removePropertyChangeListener​(java.beans.PropertyChangeListener listener)
        Description copied from interface: Ehcache
        Remove a PropertyChangeListener.
        Specified by:
        removePropertyChangeListener in interface Ehcache
        Parameters:
        listener - the PropertyChangeListener to remove

      • firePropertyChange

        public void firePropertyChange​(java.lang.String propertyName,
                               java.lang.Object oldValue,
                               java.lang.Object newValue)
        Parameters:
        propertyName - the name of the property that changed
        oldValue - the old value of the property that changed
        newValue - the new value of the property that changed

      • putIfAbsent

        public Element putIfAbsent​(Element element)
                    throws java.lang.NullPointerException
        Put an element in the cache if no element is currently mapped to the elements key.
        Specified by:
        putIfAbsent in interface Ehcache
        Parameters:
        element - element to be added
        Returns:
        the element previously cached for this key, or null if none.
        Throws:
        java.lang.NullPointerException - if the element is null, or has a null key

      • putIfAbsent

        public Element putIfAbsent​(Element element,
                           boolean doNotNotifyCacheReplicators)
                    throws java.lang.NullPointerException
        Put an element in the cache if no element is currently mapped to the elements key.
        Specified by:
        putIfAbsent in interface Ehcache
        Parameters:
        element - element to be added
        doNotNotifyCacheReplicators - whether the put is coming from a doNotNotifyCacheReplicators cache peer, in which case this put should not initiate a further notification to doNotNotifyCacheReplicators cache peers
        Returns:
        the element previously cached for this key, or null if none.
        Throws:
        java.lang.NullPointerException - if the element is null, or has a null key

      • removeElement

        public boolean removeElement​(Element element)
                      throws java.lang.NullPointerException
        Remove the Element mapped to the key for the supplied element if the value of the supplied Element compares equal to the value of the cached Element.

        This is equivalent to 

           if (elementValueComparator.equals(cache.get(element.getObjectKey()), element)) {
       return cache.remove(element.getObjectKey());
   } else return false;
        except that the action is performed atomically.
        Specified by:
        removeElement in interface Ehcache
        Parameters:
        element - Element to be removed
        Returns:
        true if the value was removed
        Throws:
        java.lang.NullPointerException - if the element is null, or has a null key
        See Also:
        CacheConfiguration.addElementValueComparator(net.sf.ehcache.config.ElementValueComparatorConfiguration)

      • replace

        public boolean replace​(Element old,
                       Element element)
                throws java.lang.NullPointerException,
                       java.lang.IllegalArgumentException
        Replace the cached element only if the current Element is equal to the supplied old Element.
        Specified by:
        replace in interface Ehcache
        Parameters:
        old - Element to be test against
        element - Element to be cached
        Returns:
        true if the Element was replaced
        Throws:
        java.lang.NullPointerException - if the either Element is null or has a null key
        java.lang.IllegalArgumentException - if the two Element keys are non-null but not equal

      • replace

        public Element replace​(Element element)
                throws java.lang.NullPointerException
        Replace the cached element only if an Element is currently cached for this key
        Specified by:
        replace in interface Ehcache
        Parameters:
        element - Element to be cached
        Returns:
        the Element previously cached for this key, or null if no Element was cached
        Throws:
        java.lang.NullPointerException - if the Element is null or has a null key

      • getSearchAttribute

        public <T> Attribute<T> getSearchAttribute​(java.lang.String attributeName)
                                    throws CacheException
        Retrieve the given named search attribute
        Specified by:
        getSearchAttribute in interface Ehcache
        Type Parameters:
        T - type of the attribute
        Parameters:
        attributeName - the name of the attribute to retrieve
        Returns:
        the search attribute
        Throws:
        CacheException - if no such attribute is defined for the given name

      • createQuery

        public Query createQuery()
        Create a new query builder for this cache
        Specified by:
        createQuery in interface Ehcache
        Returns:
        a new query builder

      • isSearchable

        public boolean isSearchable()
        Is this cache searchable?
        Specified by:
        isSearchable in interface Ehcache
        Returns:
        true if this cache is searchable

      • getLockForKey

        protected Sync getLockForKey​(java.lang.Object key)
        Gets the lock for a given key
        Parameters:
        key - the key we want the lock for
        Returns:
        the lock object for the passed in key

      • acquireReadLockOnKey

        public void acquireReadLockOnKey​(java.lang.Object key)
        Acquires the proper read lock for a given cache key
        Specified by:
        acquireReadLockOnKey in interface Ehcache
        Parameters:
        key - - The key that retrieves a value that you want to protect via locking

      • acquireWriteLockOnKey

        public void acquireWriteLockOnKey​(java.lang.Object key)
        Acquires the proper write lock for a given cache key
        Specified by:
        acquireWriteLockOnKey in interface Ehcache
        Parameters:
        key - - The key that retrieves a value that you want to protect via locking

      • tryReadLockOnKey

        public boolean tryReadLockOnKey​(java.lang.Object key,
                                long timeout)
                         throws java.lang.InterruptedException
        Try to get a read lock on a given key. If can't get it in timeout millis then return a boolean telling that it didn't get the lock
        Specified by:
        tryReadLockOnKey in interface Ehcache
        Parameters:
        key - - The key that retrieves a value that you want to protect via locking
        timeout - - millis until giveup on getting the lock
        Returns:
        whether the lock was awarded
        Throws:
        java.lang.InterruptedException - in case the thread was interrupted

      • tryWriteLockOnKey

        public boolean tryWriteLockOnKey​(java.lang.Object key,
                                 long timeout)
                          throws java.lang.InterruptedException
        Try to get a write lock on a given key. If can't get it in timeout millis then return a boolean telling that it didn't get the lock
        Specified by:
        tryWriteLockOnKey in interface Ehcache
        Parameters:
        key - - The key that retrieves a value that you want to protect via locking
        timeout - - millis until giveup on getting the lock
        Returns:
        whether the lock was awarded
        Throws:
        java.lang.InterruptedException - in case the thread was interrupted

      • releaseReadLockOnKey

        public void releaseReadLockOnKey​(java.lang.Object key)
        Release a held read lock for the passed in key
        Specified by:
        releaseReadLockOnKey in interface Ehcache
        Parameters:
        key - - The key that retrieves a value that you want to protect via locking

      • releaseWriteLockOnKey

        public void releaseWriteLockOnKey​(java.lang.Object key)
        Release a held write lock for the passed in key
        Specified by:
        releaseWriteLockOnKey in interface Ehcache
        Parameters:
        key - - The key that retrieves a value that you want to protect via locking

      • isReadLockedByCurrentThread

        public boolean isReadLockedByCurrentThread​(java.lang.Object key)
                                    throws java.lang.UnsupportedOperationException
        Returns true if a read lock for the key is held by the current thread

        Only Terracotta clustered cache instances currently support querying a thread's read lock hold status.

        Specified by:
        isReadLockedByCurrentThread in interface Ehcache
        Parameters:
        key - the key
        Returns:
        true if a read lock for the key is held by the current thread
        Throws:
        java.lang.UnsupportedOperationException - if querying the read lock state is not supported

      • isWriteLockedByCurrentThread

        public boolean isWriteLockedByCurrentThread​(java.lang.Object key)
        Returns true if a write lock for the key is held by the current thread
        Specified by:
        isWriteLockedByCurrentThread in interface Ehcache
        Parameters:
        key - the key
        Returns:
        true if a write lock for the key is held by the current thread

      • isClusterBulkLoadEnabled

        public boolean isClusterBulkLoadEnabled()
                                 throws java.lang.UnsupportedOperationException,
                                        TerracottaNotRunningException
        Returns true if at least one node in the cluster is in bulk-load mode. Returns false otherwise.

        NOTE: if Ehcache.isNodeBulkLoadEnabled() returns true, this method will always return true. Applies to caches clustered with Terracotta only.

        Specified by:
        isClusterBulkLoadEnabled in interface Ehcache
        Returns:
        true if the cache is in bulk-load mode cluster-wide, false otherwise
        Throws:
        java.lang.UnsupportedOperationException - if the cache is not clustered with Terracotta
        TerracottaNotRunningException

      • isNodeBulkLoadEnabled

        public boolean isNodeBulkLoadEnabled()
                              throws java.lang.UnsupportedOperationException,
                                     TerracottaNotRunningException
        Returns true if the current node is in bulk-load mode. Returns false otherwise.

        NOTE: if this method returns true, Ehcache.isClusterBulkLoadEnabled() method will always return true. Applies to caches clustered with Terracotta only.

        Specified by:
        isNodeBulkLoadEnabled in interface Ehcache
        Returns:
        true if the cache is in coherent mode cluster-wide, false otherwise
        Throws:
        java.lang.UnsupportedOperationException - if the cache is not clustered with Terracotta
        TerracottaNotRunningException

      • setNodeBulkLoadEnabled

        public void setNodeBulkLoadEnabled​(boolean enabledBulkLoad)
                            throws java.lang.UnsupportedOperationException,
                                   TerracottaNotRunningException
        Enable/disable bulk-load mode in this node for this cache. Calling setBulkLoadEnabled(true) when the cache is already in bulk-load mode or calling setBulkLoadEnabled(false) when already NOT in bulk-load mode will be a no-op.

        Applies to caches clustered with Terracotta only.

        When using Terracotta clustered caches with nonstop enabled, the timeout used by this method is NonstopConfiguration.getBulkOpsTimeoutMultiplyFactor() times the timeout value in the nonstop config.

        Specified by:
        setNodeBulkLoadEnabled in interface Ehcache
        Parameters:
        enabledBulkLoad - true enables bulk-load, false disables it if not already disabled
        Throws:
        java.lang.UnsupportedOperationException - if the cache is not clustered with Terracotta
        TerracottaNotRunningException

      • waitUntilClusterBulkLoadComplete

        public void waitUntilClusterBulkLoadComplete()
                                      throws java.lang.UnsupportedOperationException,
                                             TerracottaNotRunningException
        This method waits until all the connected nodes have disabled bulk-load. Or in other words, calling this method will block until all connected nodes in the cluster disables bulk-load. If none of the nodes did not enable bulk-load this method will return immediately

        Applies to caches clustered with Terracotta only.

        Specified by:
        waitUntilClusterBulkLoadComplete in interface Ehcache
        Throws:
        java.lang.UnsupportedOperationException - if the cache is not clustered with Terracotta
        TerracottaNotRunningException

      • recalculateSize

        public void recalculateSize​(java.lang.Object key)
        Recalculate the size of the element mapped to the key
        Specified by:
        recalculateSize in interface InternalEhcache
        Parameters:
        key - the key