Package org.jgroups.blocks

Class Cache<K,V>

java.lang.Object
org.jgroups.blocks.Cache<K,V>
public class Cache<K,V> extends Object
Simple cache which maintains keys and value. A reaper can be enabled which periodically evicts expired entries. Also, when the cache is configured to be bounded, entries in excess of the max size will be evicted on put().

  • Field Details

    • log

      private static final Log log

    • map

      private final ConcurrentMap<K,Cache.Value<V>> map

    • timer

      private ScheduledThreadPoolExecutor timer

    • task

      private Future task

    • is_reaping

      private final AtomicBoolean is_reaping

    • change_listeners

      private final Set<Cache.ChangeListener> change_listeners

    • max_num_entries

      private int max_num_entries
      The maximum number of keys, When this value is exceeded we evict older entries, until we drop below this mark again. This effectively maintains a bounded cache. A value of 0 means don't bound the cache.

  • Constructor Details

    • Cache

      public Cache()

  • Method Details

    • getMaxNumberOfEntries

      public int getMaxNumberOfEntries()

    • setMaxNumberOfEntries

      public void setMaxNumberOfEntries(int max_num_entries)

    • addChangeListener

      public void addChangeListener(Cache.ChangeListener l)

    • removeChangeListener

      public void removeChangeListener(Cache.ChangeListener l)

    • getSize

      public int getSize()

    • isReapingEnabled

      public boolean isReapingEnabled()

    • enableReaping

      public void enableReaping(long interval)
      Runs the reaper every interval ms, evicts expired items

    • disableReaping

      public void disableReaping()

    • start

      public void start()

    • stop

      public void stop()

    • put

      public V put(K key, V val, long caching_time)
      Parameters:
      key -
      val -
      caching_time - Number of milliseconds to keep an entry in the cache. -1 means don't cache (if reaping is enabled, we'll evict an entry with -1 caching time), 0 means never evict. In the latter case, we can still evict an entry with 0 caching time: when we have a bounded cache, we evict in order of insertion no matter what the caching time is.

    • get

      public V get(K key)

    • getInternalMap

      public ConcurrentMap<K,Cache.Value<V>> getInternalMap()
      This method should not be used to add or remove elements ! It was just added because ReplCacheDemo requires it for its data model
      Returns:

    • getEntry

      public Cache.Value<V> getEntry(K key)

    • remove

      public V remove(K key)

    • entrySet

      public Set<Map.Entry<K,Cache.Value<V>>> entrySet()

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • dump

      public String dump()

    • evict

      private void evict()

    • notifyChangeListeners

      private void notifyChangeListeners()

    • getValue

      private V getValue(Cache.Value<V> val)

    • isExpired

      private boolean isExpired(Cache.Value<V> val)