Solving a Classic Ehcache Problem – Retrieving Expired Data

We host a web application that serves a high-traffic website. This web app is backed by a content management system (CMS), and we use Ehcache to cache the data from this CMS.

The problem: How to return expired data if you’re unable to retrieve new data?

Ehcache holds cache elements in-memory/on-disk store until the defined expiration time. We’ve defined the time-to-live (TTL) to be 15 minutes (900 seconds) in eh-cache.xml:

<cache name="contentCache"</pre>
<pre style="padding-left: 30px;">maxElementsInMemory="1"</pre>
<pre style="padding-left: 30px;">maxElementsOnDisk="0"</pre>
<pre style="padding-left: 30px;">timeToLiveSeconds="900"</pre>
<pre style="padding-left: 30px;">memoryStoreEvictionPolicy="LRU"</pre>
<pre style="padding-left: 30px;">eternal="false"</pre>
<pre style="padding-left: 30px;">overflowToDisk="false"/>

Once an element in the cache expires, Ehcache does not automatically remove this element because it has exceeded its timeToLiveSeconds and timeToIdleSeconds attribute values.

Excerpt from the Ehcache documentation:

timeToIdleSeconds: Sets the time to idle for an element before it expires. In other words, the maximum amount of time between accesses before an element expires is only used if the element is not eternal. Optional attribute — a value of 0 means that an element can idle for infinity. The default value is 0.

timeToLiveSeconds: Sets the time to live for an element before it expires. In other words, the maximum time between creation time and when an element expires is only used if the element is not eternal. Optional attribute — a value of 0 means that and element can live for infinity. The default value is 0.

An expired element remains in the cache until either:

• Ehcache#evictExpiredElements() is called
• Or, a get or remove operation is called on the cache that passes in the same key as the expired element

If either of the above actions is performed, Ehcache immediately nullifies the expired element in the cache. The application would then be responsible for fetching the data for a new replacement element and repopulating the cache with this element.

In instances where the data for this new element cannot be retrieved, we want to return the stale content from the old expired element. Unfortunately, there seems to be no good extension point in Ehcache to make this change. Therefore, I decided to take control of Ehcache’s refresh mechanism to implement this desired behavior:

1. Ehcache can make a cache eternal so the elements in the cache never expire. To make a cache eternal, set the following property for the cache in ehcache.xml:

eternal="true"

1. Additionally, maintain timeToLive configuration for the cache in the code. Each time you retrieve an element from the cache, check if the cached element has exceeded its timeToLive period. If the cache expired, refresh the cache element.

Update the statistics on the cache element in order to minimize the number of threads attempting to refresh the cache. Then, try to retrieve the latest data for this cache element. If this fails, the stale data continues to be returned since the attempt to retrieve the latest data doesn’t overwrite the stale data.

Element element = getElementFromCache(cache, cacheEntryKey);
    // If the element is present in the cache, execute the refresh logic below
    if (element != null) {
        //condition for refresh 
        if (isElementInCacheExpired(cacheName, element)) {
           // logic for refreshing the cache

//The element.updateUpdateStatistics() method sets the last access time 
to now without updating the hit count. This prevents other threads 
from entering the refresh logic.
            element.updateUpdateStatistics();
            try {
 // try to retrieve latest data for this current cache element
            Object returnObj = getDataForCacheElement(cacheEntryKey);
            If(returnObj is not null){
                Element element = new Element(cacheEntryKey, 
                returnObj);
                cache.replace(element);
            }
        } catch (Exception e) {
                System.out.println("Error creating replacement element 
                for key” +cacheEntryKey);
        }
 } else {
      // retrieve data for this new cache element 
      Object returnObj = getDataForCacheElement(cacheEntryKey);
      // take the value returned and store in cache 
      Element element = new Element(cacheEntryKey, returnObj);
      cache.put(element);
 }           
 //return element from cache
element =  getElementFromCache(blockingCache, cacheEntryKey);
return element

Cache expiration logic

I compare the current time with (element.getLatestOfCreationAndUpdateTime() + TimeUtil.toMillis(timeToLive)).
(“timeToLive” is the custom configuration stored for the cache):

function isElementInCacheExpired(String cacheName, Element element){
          // The synchronized block prevents multiple threads from 
checking the expiration condition at the same time.
          synchronized (element) {
             long now = System.currentTimeMillis();
             return (now > element.getLatestOfCreationAndUpdateTime() +
             TimeUtil.toMillis(timeToLive));
          }
}

This is the approach I took to solve this classic Ehcache “Catch-22” problem that included having to return expired data when I am not able to retrieve new data. I would love to hear what other Ehcache users think about my solution. Please let me know what you think in the comments below!