FileDocCategorySizeDatePackage
BoundedMultiLruCache.javaAPI DocGlassfish v2 API7726Fri May 04 22:35:28 BST 2007com.sun.appserv.util.cache

BoundedMultiLruCache

public class BoundedMultiLruCache extends MultiLruCache
MultiLruCache -- in-memory bounded LRU cache with multiple LRU lists Underlying Hashtable is made into logical segments, with each segment having its own LRU list.

Fields Summary
protected long
maxSize
protected long
currentSize
private Object
currentSizeLk
Constructors Summary
Methods Summary
protected final voiddecrementCurrentSize(int size)

        synchronized(currentSizeLk) {
            currentSize -= size;
        }
public java.lang.ObjectgetStatByName(java.lang.String key)
get the desired statistic counter

param
key to corresponding stat
return
an Object corresponding to the stat See also: Constant.java for the key

        Object stat = super.getStatByName(key);

        if (stat == null && key != null) {
            if (key.equals(Constants.STAT_BOUNDEDMULTILRUCACHE_CURRENT_SIZE))
                stat = Long.valueOf(currentSize);
            else if (key.equals(Constants.STAT_BOUNDEDMULTILRUCACHE_MAX_SIZE)) {
                if (maxSize == Constants.DEFAULT_MAX_CACHE_SIZE)
                    stat = Constants.STAT_DEFAULT;
                else
                    stat = Long.valueOf(maxSize);
            }
        }

        return stat;
public java.util.MapgetStats()

        Map stats = super.getStats();

        // cache size in KB
        stats.put(Constants.STAT_BOUNDEDMULTILRUCACHE_CURRENT_SIZE,
                  Long.valueOf(currentSize));
        if (maxSize == Constants.DEFAULT_MAX_CACHE_SIZE) {
            stats.put(Constants.STAT_BOUNDEDMULTILRUCACHE_MAX_SIZE,
                      Constants.STAT_DEFAULT);
        }
        else {
            stats.put(Constants.STAT_BOUNDEDMULTILRUCACHE_MAX_SIZE,
                      Long.valueOf(maxSize));
        }
        return stats;
protected final voidincrementCurrentSize(int size)
synchronized counter updates

        synchronized(currentSizeLk) {
            currentSize += size;
        }
public voidinit(int maxCapacity, java.util.Properties props)
initialize the LRU cache

param
maxCapacity maximum number of entries this cache may hold


                       
            
        super.init(maxCapacity, props);
        currentSize = 0;

        if (props != null) {
            String strMaxSize = props.getProperty("MaxSize");
            int multiplier = 1;
            long size = -1;

            String prop = strMaxSize;
            if (prop != null) {
                int index;

                // upper case the string
                prop = prop.toUpperCase();

                // look for 200KB or 80Kb or 1MB or 2Mb like suffixes
                if ((index = prop.indexOf("KB")) != -1) {
                    multiplier = Constants.KB;
                    prop = prop.substring(0, index);
                } else if ((index = prop.indexOf("MB")) != -1) {
                    multiplier = Constants.MB;
                    prop = prop.substring(0, index);
                }

                try {
                    size = Long.parseLong(prop.trim());
                } catch (NumberFormatException nfe) {}
            }

            // sanity check and convert
            if (size > 0)
                maxSize = (size * multiplier);
            else  {
                String msg = _rb.getString("cache.BoundedMultiLruCache.illegalMaxSize");

                Object[] params = { strMaxSize };
                msg = MessageFormat.format(msg, params);

                throw new IllegalArgumentException(msg);
            }
        }
protected booleanisThresholdReached()
has cache reached its threshold

return
true when the cache reached its threshold

        return (currentSize > maxSize || super.isThresholdReached());
protected CacheItemitemAdded(CacheItem item)
this item is just added to the cache

param
item CacheItem that was created
return
a overflow item; may be null Cache bucket is already synchronized by the caller

        LruCacheItem overflow = (LruCacheItem) super.itemAdded(item);

        // update the size
        if (overflow != null) {
            decrementCurrentSize(overflow.getSize());
        }
        incrementCurrentSize(item.getSize());

        return overflow;
protected voiditemRefreshed(CacheItem item, int oldSize)
item value has been refreshed

param
item CacheItem that was refreshed
param
oldSize size of the previous value that was refreshed Cache bucket is already synchronized by the caller

        super.itemRefreshed(item, oldSize);

        /** reduce the cache by the size of the size of the previous value 
         *  and increment by the value being refreshed with.
         */
        decrementCurrentSize(oldSize);
        incrementCurrentSize(item.getSize());
protected voiditemRemoved(CacheItem item)
item value has been removed from the cache

param
item CacheItem that was just removed Cache bucket is already synchronized by the caller

        super.itemRemoved(item);

        // update the size
        decrementCurrentSize(item.getSize());