/** * trim the item from the cache and notify listeners * @param item to be trimmed */ protected void trimItem(CacheItem item) { LruCacheItem removed = (LruCacheItem) item; if (removeIfIdle) { StatefulEJBContext ctx = (StatefulEJBContext) item.getValue(); long idleThreshold = System.currentTimeMillis() - removalTimeoutInSeconds*1000L; if (ctx.getLastAccessTime() <= idleThreshold) { container.passivateEJB(ctx); return; } } for (int i = 0; i < listeners.size(); i++) { CacheListener listener = (CacheListener) listeners.get(i); listener.trimEvent(removed.getKey(), removed.getValue()); } }
StatefulEJBContext ctx = (StatefulEJBContext) item.getValue(); if (ctx != null) { item.setTrimmed(true); victimList.add(item); } else { if( (item == head) && (item.getLPrev() != null) ) { _logger.log(Level.WARNING, TRIM_TIMEDOUT_BEANS_RESETTING_HEAD_LPREV, cacheName); item.setLPrev(null); item = item.getLPrev(); if (item == null) { break; item.getLNext().setLPrev(null); item.getLNext().setLNext(null); item.setLNext(null);
break; if (!litem.isTrimmed()) { itemRemoved(litem); litem.setTrimmed(true); victims.add(litem);
public void shutdown() { ArrayList<StatefulEJBContext> valueList = new ArrayList<StatefulEJBContext>(); synchronized (this) { LruCacheItem item = tail; while (item != null) { StatefulEJBContext ctx = (StatefulEJBContext) item.getValue(); if (ctx != null) { item.setTrimmed(true); valueList.add(ctx); } // Ensure that for head the lPrev is null if ((item == head) && (item.getLPrev() != null)) { _logger.log(Level.WARNING, ITERATOR_RESETTING_HEAD_LPREV, cacheName); item.setLPrev(null); } // traverse to the previous one item = item.getLPrev(); } } for (StatefulEJBContext ctx : valueList) { container.passivateEJB(ctx); } }
/** * get an Iterator for the values stored in the cache * @returns an Iterator */ public Iterator values() { ArrayList valueList = new ArrayList(); synchronized (this) { LruCacheItem item = tail; while (item != null) { StatefulEJBContext ctx = (StatefulEJBContext) item.getValue(); if (ctx != null) { valueList.add(ctx); } //Ensure that for head the lPrev is null if( (item == head) && (item.getLPrev() != null) ) { _logger.log(Level.WARNING, ITERATOR_RESETTING_HEAD_LPREV, cacheName); item.setLPrev(null); } // traverse to the previous one item = item.getLPrev(); } } return valueList.iterator(); }
@Override protected CacheItem trimLru(long currentTime) { LruCacheItem trimItem = tail; if (tail != head) { tail = trimItem.getLPrev(); if (tail == null) { _logger.log(Level.WARNING, TRIM_LRU_RESETTING_HEAD_AND_TAIL, cacheName); // do not let the tail go past the head tail = head = null; } else { tail.setLNext(null); } } else { tail = head = null; } if (trimItem != null) { trimItem.setTrimmed(true); trimItem.setLPrev(null); trimCount++; listSize--; } return trimItem; }
protected void itemAccessed(CacheItem item) { LruCacheItem lc = (LruCacheItem) item; synchronized (this) { if (lc.isTrimmed()) { lc.setTrimmed(false); numVictimsAccessed += 1; CacheItem overflow = super.itemAdded(item); if (overflow != null) { trimItem(overflow); } } else { super.itemAccessed(item); } } }
/** * create new item * @param hashCode for the entry * @param key <code>Object</code> key * @param value <code>Object</code> value * @param size size in bytes of the item * * subclasses may override to provide their own CacheItem extensions * e.g. one that permits persistence. */ protected CacheItem createItem(int hashCode, Object key, Object value, int size) { return new LruCacheItem(hashCode, key, value, size); }
protected void itemAccessed(CacheItem item) { LruCacheItem lc = (LruCacheItem) item; synchronized (this) { if (lc.isTrimmed()) { lc.setTrimmed(false); CacheItem overflow = super.itemAdded(item); if (overflow != null) { trimItem(overflow); } } else if (doOrdering) { super.itemAccessed(item); } } }
/** * create new item * @param hashCode for the entry * @param key <code>Object</code> key * @param value <code>Object</code> value * @param size size in bytes of the item * * subclasses may override to provide their own CacheItem extensions * e.g. one that permits persistence. */ protected CacheItem createItem(int hashCode, Object key, Object value, int size) { return new LruCacheItem(hashCode, key, value, size); }
/** * create new item * @param hashCode for the entry * @param key <code>Object</code> key * @param value <code>Object</code> value * @param size size in bytes of the item * * subclasses may override to provide their own CacheItem extensions * e.g. one that permits persistence. */ protected CacheItem createItem(int hashCode, Object key, Object value, int size) { return new LruCacheItem(hashCode, key, value, size); }
/** * create new item * @param hashCode for the entry * @param key <code>Object</code> key * @param value <code>Object</code> value * @param size size in bytes of the item * * subclasses may override to provide their own CacheItem extensions * e.g. one that permits persistence. */ protected CacheItem createItem(int hashCode, Object key, Object value, int size) { return new LruCacheItem(hashCode, key, value, size); }
protected void itemAccessed(CacheItem item) { LruCacheItem lc = (LruCacheItem) item; synchronized (this) { if (lc.isTrimmed()) { lc.setTrimmed(false); CacheItem overflow = super.itemAdded(item); if (overflow != null) { trimItem(overflow); } } } }