org.boon.cache

Class SimpleConcurrentCache<K,V>

java.lang.Object

org.boon.cache.SimpleConcurrentCache<K,V>

Type Parameters:

K -

V -

All Implemented Interfaces:

Cache<K,V>

public class SimpleConcurrentCache<K,V>
extends Object
implements Cache<K,V>

Uses striping to allow more than one thread to operate on the cache at a time, but due to the nature of the independent tracking of each strip the exact LRUness liveness is only an approximation. The tradeoff is speed for LRU approximation. Basically the very least recently used is not always harvested but one of the stripes will harvest one of the least recently used. So if you cache size was 10,000 and you had 8 CPUs, then a reaping would only get one of the least recently used, but maybe not the most least but within the least +-8.

Constructor Summary

Constructors

Constructor and Description
SimpleConcurrentCache(int limit) New
SimpleConcurrentCache(int limit, boolean fair, CacheType type) Limit of hte cache size
SimpleConcurrentCache(int limit, CacheType type) New
SimpleConcurrentCache(int concurrency, int limit, boolean fair) The more stripes the less accurate the LRU but the faster the access.
SimpleConcurrentCache(int concurrency, int limit, boolean fair, CacheType type) The more stripes the less accurate the LRU but the faster the access.

Method Summary

Methods

Modifier and Type	Method and Description
V	get(K key) Take the key out.
V	getSilent(K key) for testing only.
void	put(K key, V value) Put the key in.
void	remove(K key) Remove the key
int	size() Get the size of the cache.
String	toString() toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

SimpleConcurrentCache

public SimpleConcurrentCache(int limit)

New

Parameters:

limit - limit of the cache size

SimpleConcurrentCache

public SimpleConcurrentCache(int limit,
                     CacheType type)

New

Parameters:

limit - limit of the cache size

type - type of cache

SimpleConcurrentCache

public SimpleConcurrentCache(int limit,
                     boolean fair,
                     CacheType type)

Limit of hte cache size

Parameters:

limit - limit of the cache size

fair - should we be fair?

type - type of cache

SimpleConcurrentCache

public SimpleConcurrentCache(int concurrency,
                     int limit,
                     boolean fair,
                     CacheType type)

The more stripes the less accurate the LRU but the faster the access. Life is all about engineering trade-offs. 100,000 entries ok with 100 stripes, but 10 entries not so cool with 10 stripes. Try to keep the accuracy in the 1% to 5% range.

Parameters:

concurrency - how many stripes

limit - limit of the cache size

fair - should we be fair?

type - type of cache

SimpleConcurrentCache

public SimpleConcurrentCache(int concurrency,
                     int limit,
                     boolean fair)

The more stripes the less accurate the LRU but the faster the access. Life is all about engineering trade-offs.

Parameters:

concurrency - how many stripes

limit - limit of the cache size

fair - should we be fair?

Method Detail

put

public void put(K key,
       V value)

Put the key in.

Specified by:

put in interface Cache<K,V>

Parameters:

key - the key

value - the value

get

public V get(K key)

Take the key out.

Specified by:

get in interface Cache<K,V>

Parameters:

key - the key

Returns:

value

getSilent

public V getSilent(K key)

for testing only.

Specified by:

getSilent in interface Cache<K,V>

Parameters:

key - key to get the value with

Returns:

the value

remove

public void remove(K key)

Remove the key

Specified by:

remove in interface Cache<K,V>

Parameters:

key - the key

size

public int size()

Get the size of the cache. This is not 100% accurate if cache is being concurrenly accessed.

Specified by:

size in interface Cache<K,V>

toString

public String toString()

toString

Overrides:

toString in class Object

Returns:

string