ShiftOne Java Object Cache Policies

First In First Out

The FIFO policy is a simple algorithm strategy, elements are evicted in the same order they were added to the cache. The simplicity of this replacement algorithm typically makes this cache the fastest. This does not mean that the cache will improve application performance the most, only that accesses to the cache will take the least amount of time.

This replacement policy is recommended when cache gets are truly random - when the likelihood of an object being requested does not have a bearing on the likelihood of the same object being requested again.

This strategy has a bias towards fresher data.

Least Recently Used

The LRU policy is a variation of the FIFO policy. The only real difference between the two is that LRU "boosts" objects when they are accessed. When an object is accessed, the cache re-prioritize that object, causing it to remain in the cache longer. Note that usage and priority does not effect the node's expiration.

This policy is generally recommended when cache access is non-random. This is commonly the case for applications that need to cache data that users request, and some data is more "popular" than others. For example, on a news website, headlines are going to get more hits, and should therefore remain in cache longer.

This strategy has a bias towards more recently used data.

Least Frequently Used

LFU is a policy that evicts objects that are "least frequently used". In this strategy, elements are evicted based when they were added, when they were last used, and how many times they have been used.

This policy should be used if an object that has been used many times is likely to be used again, even if other objects have been used more recently. This algorithm has the effect of making some objects, those that were used several times, much more durable in the cache.

This strategy has a bias towards data that has been hit more times.

Single

This cache implements the degenerative case of a cache that only allows a single object to be stored (has a max size of one). Obviously, if you only want to cache a single object, the cache implementation can be very efficient.

Zero

This cache implements the degenerative case of a cache that doesn't hold any objects. This is an effective and clean way to turn caching off in an application, without adding code.