Package gw.util.concurrent

Class Cache<K,V>

java.lang.Object

gw.util.concurrent.Cache<K,V>

Direct Known Subclasses:

TypeSystemAwareCache

public class Cache<K,V>
extends java.lang.Object

static var MY_CACHE = new Cache( 1000, \ foo -> getBar( foo ) )

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	Cache.ConcurrentLinkedHashMap<K,V>	A ConcurrentMap with a doubly-linked list running through its entries.
static interface	Cache.MissHandler<L,W>

Field Summary

Fields

Modifier and Type	Field	Description
private Cache.ConcurrentLinkedHashMap<K,V>	_cacheImpl
private java.util.concurrent.atomic.AtomicInteger	_hits
private java.util.concurrent.ScheduledFuture<?>	_loggingTask
private java.util.concurrent.atomic.AtomicInteger	_misses
private Cache.MissHandler<K,V>	_missHandler
private java.lang.String	_name
private java.util.concurrent.atomic.AtomicInteger	_requests
private int	_size

Constructor Summary

Constructors

Constructor	Description
Cache(java.lang.String name, int size, Cache.MissHandler<K,V> missHandler)	This will create a new cache

Method Summary

Modifier and Type	Method	Description
void	clear()
private void	clearCacheImpl()
V	evict(K key)	This will evict a specific key from the cache.
V	get(K key)	This will get a specific entry, it will call the missHandler if it is not found.
int	getConfiguredSize()
double	getHitRate()
int	getHits()
int	getMisses()
int	getRequests()
int	getUtilizedSize()
Cache<K,V>	logEveryNSeconds(int seconds, ILogger logger)	Sets up a recurring task every n seconds to report on the status of this cache.
static <K,V> Cache<K,V>	make(java.lang.String name, int size, Cache.MissHandler<K,V> handler)
V	put(K key, V value)	This will put a specific entry in the cache
void	stopLogging()
java.lang.String	toString()

Methods inherited from class java.lang.Object

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

Field Detail

_cacheImpl

private Cache.ConcurrentLinkedHashMap<K,V> _cacheImpl

_missHandler

private final Cache.MissHandler<K,V> _missHandler

_name

private final java.lang.String _name

_size

private final int _size

_requests

private final java.util.concurrent.atomic.AtomicInteger _requests

_misses

private final java.util.concurrent.atomic.AtomicInteger _misses

_hits

private final java.util.concurrent.atomic.AtomicInteger _hits

_loggingTask

private java.util.concurrent.ScheduledFuture<?> _loggingTask

Constructor Detail

Cache

public Cache(java.lang.String name,
             int size,
             Cache.MissHandler<K,V> missHandler)

This will create a new cache

Parameters:

name - the name of the cache for logging

size - the maximum size of the log

missHandler - how to handle misses, this is required not to be null

Method Detail

clearCacheImpl

private void clearCacheImpl()

evict

public V evict(K key)

This will evict a specific key from the cache.

Parameters:

key - the key to evict

Returns:

the current value for that key

put

public V put(K key,
             V value)

This will put a specific entry in the cache

Parameters:

key - this is the key

value - this is the value

Returns:

the old value for this key

get

public V get(K key)

This will get a specific entry, it will call the missHandler if it is not found.

Parameters:

key - the object to find

Returns:

the found object (may be null)

getConfiguredSize

public int getConfiguredSize()

getUtilizedSize

public int getUtilizedSize()

getRequests

public int getRequests()

getMisses

public int getMisses()

getHits

public int getHits()

getHitRate

public double getHitRate()

logEveryNSeconds

public Cache<K,V> logEveryNSeconds(int seconds,
                                         ILogger logger)

Sets up a recurring task every n seconds to report on the status of this cache. This can be useful if you are doing exploratory caching and wish to monitor the performance of this cache with minimal fuss. Consider

Parameters:

seconds - how often to log the entry

logger - the logger to use

Returns:

this

stopLogging

public void stopLogging()

clear

public void clear()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

make

public static <K,V> Cache<K,V> make(java.lang.String name,
                                                int size,
                                                Cache.MissHandler<K,V> handler)