BaseEvictionAlgorithm (JBoss Cache - Core Edition 3.2.8.GA API)

java.lang.Object
- org.jboss.cache.eviction.BaseEvictionAlgorithm

All Implemented Interfaces:

EvictionAlgorithm

Direct Known Subclasses:

BaseSortedEvictionAlgorithm, ExpirationAlgorithm, FIFOAlgorithm, LRUAlgorithm, MRUAlgorithm
```
public abstract class BaseEvictionAlgorithm
extends Object
implements EvictionAlgorithm
```
Abstract Event Processing Eviction Algorithm. This class is used to implement basic event processing for Eviction Algorithms. To extend this abstract class to make an Eviction Algorithm, implement the abstract methods and a policy.

Version:

$Revision: 8443 $

Author:

Daniel Huang - dhuang@jboss.org 10/2005, Galder Zamarreno

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`allowTombstones`
`protected CacheSPI<?,?>`	`cache`
`protected Configuration`	`configuration`
`protected EvictionActionPolicy`	`evictionActionPolicy`
`protected EvictionAlgorithmConfig`	`evictionAlgorithmConfig`
`protected EvictionQueue`	`evictionQueue` Contains NodeEntry instances.
`protected BlockingQueue<Fqn>`	`recycleQueue` Contains Fqn instances.
`protected Fqn`	`regionFqn`

Constructor Summary

Constructors
Modifier Constructor and Description

protected BaseEvictionAlgorithm()

Constructors
Modifier	Constructor and Description
`protected`	`BaseEvictionAlgorithm()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`assignToRegion(Fqn fqn, CacheSPI<?,?> cache, EvictionAlgorithmConfig evictionAlgorithmConfig, Configuration configuration)` Assigns the algorithm instance to a specific region.
`boolean`	`canIgnoreEvent(EvictionEvent.Type eventType)` Tests whether the algorithm would ignore certain event types on certain Fqns.
`protected void`	`emptyRecycleQueue()` Empty the Recycle Queue.
`protected void`	`evict(NodeEntry ne)`
`protected boolean`	`evictCacheNode(Fqn fqn)` Evict a node from cache.
`EvictionActionPolicy`	`getEvictionActionPolicy()`
`EvictionAlgorithmConfig`	`getEvictionAlgorithmConfig()`
`EvictionQueue`	`getEvictionQueue()` Get the underlying EvictionQueue implementation.
`protected EvictionEvent`	`getNextInQueue(BlockingQueue<EvictionEvent> queue)`
`void`	`initialize()` Invoked by the region manager when the enclosing region is initialized.
`protected boolean`	`isNodeInUseAndNotTimedOut(NodeEntry ne)`
`protected boolean`	`isYoungerThanMinimumTimeToLive(NodeEntry entry)` Tests whether a node entry is younger than the minimum time to live - if one is configured.
`void`	`process(BlockingQueue<EvictionEvent> eventQueue)` Process the given eviction event queue.
`protected void`	`processAddedElement(EvictionEvent evictedEventNode)`
`protected void`	`processAddedNodes(EvictionEvent evictedEventNode)` Convenience method, which calls `processAddedNodes(EvictionEvent, int)` using values in the evictedEventNode for number of added elements and the resetElementCount flag.
`protected void`	`processAddedNodes(EvictionEvent evictedEventNode, int numAddedElements)`
`protected void`	`processMarkInUseNodes(Fqn fqn, long inUseTimeout)`
`protected void`	`processQueues(BlockingQueue<EvictionEvent> queue)` Event processing for Evict/Add/Visiting of nodes.
`protected void`	`processRemovedElement(EvictionEvent evictedEventNode)`
`protected void`	`processRemovedNodes(EvictionEvent evictedEventNode)` Remove a node from cache.
`protected void`	`processUnmarkInUseNodes(Fqn fqn)`
`protected void`	`processVisitedNodes(EvictionEvent evictedEventNode)` Visit a node in cache.
`protected void`	`prune()`
`void`	`resetEvictionQueue()` Reset the whole eviction queue.
`void`	`setEvictionActionPolicy(EvictionActionPolicy evictionActionPolicy)` Sets the eviction action policy, so the algorithm knows what to do when a node is to be evicted.
`protected abstract EvictionQueue`	`setupEvictionQueue()` This method will create an EvictionQueue implementation and prepare it for use.
`protected abstract boolean`	`shouldEvictNode(NodeEntry ne)` This method will check whether the given node should be evicted or not.
`String`	`toString()` Returns debug information.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.jboss.cache.eviction.EvictionAlgorithm
getConfigurationClass

- Field Detail
  - evictionActionPolicy
```
protected EvictionActionPolicy evictionActionPolicy
```
  - evictionAlgorithmConfig
```
protected EvictionAlgorithmConfig evictionAlgorithmConfig
```
  - recycleQueue
```
protected BlockingQueue<Fqn> recycleQueue
```
    Contains Fqn instances.
  - evictionQueue
```
protected EvictionQueue evictionQueue
```
    Contains NodeEntry instances.
  - allowTombstones
```
protected boolean allowTombstones
```
  - configuration
```
protected Configuration configuration
```
  - regionFqn
```
protected Fqn regionFqn
```
  - cache
```
protected CacheSPI<?,?> cache
```
- Constructor Detail
  - BaseEvictionAlgorithm
```
protected BaseEvictionAlgorithm()
```
- Method Detail
  - setupEvictionQueue
```
protected abstract EvictionQueue setupEvictionQueue()
                                             throws EvictionException
```
    This method will create an EvictionQueue implementation and prepare it for use.
    
    Returns:
    The created EvictionQueue to be used as the eviction queue for this algorithm.
    
    Throws:
    
    EvictionException - if there are problems
    See Also:
    EvictionQueue
  - shouldEvictNode
```
protected abstract boolean shouldEvictNode(NodeEntry ne)
```
    This method will check whether the given node should be evicted or not.
    
    Parameters:
    ne - NodeEntry to test eviction for.
    
    Returns:
    True if the given node should be evicted. False if the given node should not be evicted.
  - initialize
```
public void initialize()
```
    Description copied from interface: EvictionAlgorithm
    
    Invoked by the region manager when the enclosing region is initialized.
    
    Specified by:
    
    initialize in interface EvictionAlgorithm
  - getEvictionActionPolicy
```
public EvictionActionPolicy getEvictionActionPolicy()
```
  - setEvictionActionPolicy
```
public void setEvictionActionPolicy(EvictionActionPolicy evictionActionPolicy)
```
    Description copied from interface: EvictionAlgorithm
    
    Sets the eviction action policy, so the algorithm knows what to do when a node is to be evicted.
    
    Specified by:
    
    setEvictionActionPolicy in interface EvictionAlgorithm
    
    Parameters:
    evictionActionPolicy - to set
  - getEvictionAlgorithmConfig
```
public EvictionAlgorithmConfig getEvictionAlgorithmConfig()
```
  - assignToRegion
```
public void assignToRegion(Fqn fqn,
                  CacheSPI<?,?> cache,
                  EvictionAlgorithmConfig evictionAlgorithmConfig,
                  Configuration configuration)
```
    Description copied from interface: EvictionAlgorithm
    
    Assigns the algorithm instance to a specific region.
    
    Specified by:
    
    assignToRegion in interface EvictionAlgorithm
    
    Parameters:
    fqn - of the region to be assigned to
    cache - cache reference
    evictionAlgorithmConfig - configuration for the current algorithm instance.
    configuration - for the entire cache.
  - canIgnoreEvent
```
public boolean canIgnoreEvent(EvictionEvent.Type eventType)
```
    Description copied from interface: EvictionAlgorithm
    
    Tests whether the algorithm would ignore certain event types on certain Fqns.
    
    Specified by:
    
    canIgnoreEvent in interface EvictionAlgorithm
    
    Parameters:
    eventType - event type to test for
    
    Returns:
    true if the event representing the parameters would be ignored by this algorithm or not.
  - process
```
public void process(BlockingQueue<EvictionEvent> eventQueue)
             throws EvictionException
```
    Process the given eviction event queue. Eviction Processing encompasses the following:
    - Add/Remove/Visit Nodes - Prune according to Eviction Algorithm - Empty/Retry the recycle queue of previously evicted but locked (during actual cache eviction) nodes.
    
    Specified by:
    
    process in interface EvictionAlgorithm
    
    Parameters:
    eventQueue - queue containing eviction events
    
    Throws:
    
    EvictionException
  - resetEvictionQueue
```
public void resetEvictionQueue()
```
    Description copied from interface: EvictionAlgorithm
    
    Reset the whole eviction queue. The queue may need to be reset due to corrupted state, for example.
    
    Specified by:
    
    resetEvictionQueue in interface EvictionAlgorithm
  - getEvictionQueue
```
public EvictionQueue getEvictionQueue()
```
    Get the underlying EvictionQueue implementation.
    
    Specified by:
    
    getEvictionQueue in interface EvictionAlgorithm
    
    Returns:
    the EvictionQueue used by this algorithm
    See Also:
    EvictionQueue
  - getNextInQueue
```
protected EvictionEvent getNextInQueue(BlockingQueue<EvictionEvent> queue)
```
  - processQueues
```
protected void processQueues(BlockingQueue<EvictionEvent> queue)
                      throws EvictionException
```
    Event processing for Evict/Add/Visiting of nodes.
    - On AddEvents a new element is added into the eviction queue - On RemoveEvents, the removed element is removed from the eviction queue. - On VisitEvents, the visited node has its eviction statistics updated (idleTime, numberOfNodeVisists, etc..)
    
    Parameters:
    queue - queue to inspect
    
    Throws:
    
    EvictionException - in the event of problems
  - evict
```
protected void evict(NodeEntry ne)
```
  - evictCacheNode
```
protected boolean evictCacheNode(Fqn fqn)
```
    Evict a node from cache.
    
    Parameters:
    fqn - node corresponds to this fqn
    
    Returns:
    True if successful
  - processMarkInUseNodes
```
protected void processMarkInUseNodes(Fqn fqn,
                         long inUseTimeout)
                              throws EvictionException
```
    Throws:
    
    EvictionException
  - processUnmarkInUseNodes
```
protected void processUnmarkInUseNodes(Fqn fqn)
                                throws EvictionException
```
    Throws:
    
    EvictionException
  - processAddedNodes
```
protected void processAddedNodes(EvictionEvent evictedEventNode)
                          throws EvictionException
```
    Convenience method, which calls processAddedNodes(EvictionEvent, int) using values in the evictedEventNode for number of added elements and the resetElementCount flag.
    
    Parameters:
    evictedEventNode - an evictedEventNode to process
    
    Throws:
    
    EvictionException - on problems
  - processAddedNodes
```
protected void processAddedNodes(EvictionEvent evictedEventNode,
                     int numAddedElements)
                          throws EvictionException
```
    Throws:
    
    EvictionException
  - processRemovedNodes
```
protected void processRemovedNodes(EvictionEvent evictedEventNode)
                            throws EvictionException
```
    Remove a node from cache.
    This method will remove the node from the eviction queue as well as evict the node from cache.
    If a node cannot be removed from cache, this method will remove it from the eviction queue and place the element into the recycleQueue. Each node in the recycle queue will get retried until proper cache eviction has taken place.
    Because EvictionQueues are collections, when iterating them from an iterator, use iterator.remove() to avoid ConcurrentModificationExceptions. Use the boolean parameter to indicate the calling context.
    
    Throws:
    
    EvictionException
  - processVisitedNodes
```
protected void processVisitedNodes(EvictionEvent evictedEventNode)
                            throws EvictionException
```
    Visit a node in cache.
    This method will update the numVisits and modifiedTimestamp properties of the Node. These properties are used as statistics to determine eviction (LRU, LFU, MRU, etc..)
    *Note* that this method updates Node Entries by reference and does not put them back into the queue. For some sorted collections, a remove, and a re-add is required to maintain the sorted order of the elements.
    
    Throws:
    
    EvictionException
  - processRemovedElement
```
protected void processRemovedElement(EvictionEvent evictedEventNode)
                              throws EvictionException
```
    Throws:
    
    EvictionException
  - processAddedElement
```
protected void processAddedElement(EvictionEvent evictedEventNode)
                            throws EvictionException
```
    Throws:
    
    EvictionException
  - emptyRecycleQueue
```
protected void emptyRecycleQueue()
                          throws EvictionException
```
    Empty the Recycle Queue.
    This method will go through the recycle queue and retry to evict the nodes from cache.
    
    Throws:
    
    EvictionException
  - isNodeInUseAndNotTimedOut
```
protected boolean isNodeInUseAndNotTimedOut(NodeEntry ne)
```
  - prune
```
protected void prune()
              throws EvictionException
```
    Throws:
    
    EvictionException
  - toString
```
public String toString()
```
    Returns debug information.
    
    Overrides:
    
    toString in class Object
  - isYoungerThanMinimumTimeToLive
```
protected boolean isYoungerThanMinimumTimeToLive(NodeEntry entry)
```
    Tests whether a node entry is younger than the minimum time to live - if one is configured.
    
    Parameters:
    entry - the node entry being examined
    
    Returns:
    true if the node is younger than - or exactly equal to - the minimum time to live, if one is configured for the given region. False otherwise.

Class BaseEvictionAlgorithm

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.jboss.cache.eviction.EvictionAlgorithm

Field Detail

evictionActionPolicy

evictionAlgorithmConfig

recycleQueue

evictionQueue

allowTombstones

configuration

regionFqn

cache

Constructor Detail

BaseEvictionAlgorithm

Method Detail

setupEvictionQueue

shouldEvictNode

initialize

getEvictionActionPolicy

setEvictionActionPolicy

getEvictionAlgorithmConfig

assignToRegion

canIgnoreEvent

process

resetEvictionQueue

getEvictionQueue

getNextInQueue

processQueues

evict

evictCacheNode

processMarkInUseNodes

processUnmarkInUseNodes

processAddedNodes

processAddedNodes

processRemovedNodes

processVisitedNodes

processRemovedElement

processAddedElement

emptyRecycleQueue

isNodeInUseAndNotTimedOut

prune

toString

isYoungerThanMinimumTimeToLive