jodd-cache集锦（jet cache）

Jodd cache提供了一组cache的实现，其层次如下：

其中，

AbstractCacheMap是一个具有计时和大小的缓存map的默认实现，它的实现类必须：

　　创建一个新的缓存map。

　　实现自己的删除(prune)策略。

内部使用ReentranReadWriteLock来同步。因为从一个读锁升级到一个写锁是不可能的，因此在get(Object)方法内要注意。

FIFOCach：先进先出缓存。

优点是简单高效。缺点是不灵活，没有在内存中保存常用的缓存对象。

/**
 * Creates a new LRU cache.
 */
 public FIFOCache(int cacheSize, long timeout) {
 this.cacheSize = cacheSize;
 this.timeout = timeout;
 cacheMap = new LinkedHashMap<K,CacheObject<K,V>>(cacheSize + 1, 1.0f, false);
 }


 // ---------------------------------------------------------------- prune

 /**
 * Prune expired objects and, if cache is still full, the first one.
 */
 @Override
 protected int pruneCache() {
 int count = 0;
 CacheObject<K,V> first = null;
 Iterator<CacheObject<K,V>> values = cacheMap.values().iterator();
 while (values.hasNext()) {
 CacheObject<K,V> co = values.next();
 if (co.isExpired() == true) {
 values.remove();
 count++;
 }
 if (first == null) {
 first = co;
 }
 }
 if (isFull()) {
 if (first != null) {
 cacheMap.remove(first.key);
 count++;
 }
 }
 return count;
 }

LFUCache：最少访问次数缓存。

优点是常用缓存保留在内存中，偶然会使扫描算法失效。缺点是大的获取消耗即这个算法不能快速适应变化的使用模式，特别是集群的临时获取是无效的。

public LFUCache(int maxSize, long timeout) {
 this.cacheSize = maxSize;
 this.timeout = timeout;
 cacheMap = new HashMap<K, CacheObject<K,V>>(maxSize + 1);
 }

 // ---------------------------------------------------------------- prune

 /**
 * Prunes expired and, if cache is still full, the LFU element(s) from the cache.
 * On LFU removal, access count is normalized to value which had removed object.
 * Returns the number of removed objects.
 */
 @Override
 protected int pruneCache() {
 int count = 0;
 CacheObject<K,V> comin = null;

 // remove expired items and find cached object with minimal access count
 Iterator<CacheObject<K,V>> values = cacheMap.values().iterator();
 while (values.hasNext()) {
 CacheObject<K,V> co = values.next();
 if (co.isExpired() == true) {
 values.remove();
 onRemove(co.key, co.cachedObject);
 count++;
 continue;
 }
 
 if (comin == null) {
 comin = co;
 } else {
 if (co.accessCount < comin.accessCount) {
 comin = co;
 }
 }
 }

 if (isFull() == false) {
 return count;
 }

 // decrease access count to all cached objects
 if (comin != null) {
 long minAccessCount = comin.accessCount;

 values = cacheMap.values().iterator();
 while (values.hasNext()) {
 CacheObject<K, V> co = values.next();
 co.accessCount -= minAccessCount;
 if (co.accessCount <= 0) {
 values.remove();
 onRemove(co.key, co.cachedObject);
 count++; 
 }
 }
 }
 return count;
 }

LRUCache：最近未访问缓存。

缓存对象的消耗是一个常量。简单高效，比FIFO更适应一个变化的场景。缺点是可能会被不会重新访问的缓存占满空间，特别是在面对获取类型扫描时则完全不起作用。然后它是目前最常用的缓存算法。

/**
 * Creates a new LRU cache.
 */
 public LRUCache(int cacheSize, long timeout) {
 this.cacheSize = cacheSize;
 this.timeout = timeout;
 cacheMap = new LinkedHashMap<K, CacheObject<K,V>>(cacheSize + 1, 1.0f, true) {
 @Override
 protected boolean removeEldestEntry(Map.Entry eldest) {
 return LRUCache.this.removeEldestEntry(size());
 }
 };
 }

 /**
 * Removes the eldest entry if current cache size exceed cache size.
 */
 protected boolean removeEldestEntry(int currentSize) {
 if (cacheSize == 0) {
 return false;
 }
 return currentSize > cacheSize;
 }

 // ---------------------------------------------------------------- prune

 /**
 * Prune only expired objects, <code>LinkedHashMap</code> will take care of LRU if needed.
 */
 @Override
 protected int pruneCache() {
 if (isPruneExpiredActive() == false) {
 return 0;
 }
 int count = 0;
 Iterator<CacheObject<K,V>> values = cacheMap.values().iterator();
 while (values.hasNext()) {
 CacheObject<K,V> co = values.next();
 if (co.isExpired() == true) {
 values.remove();
 count++;
 }
 }
 return count;
 }

TimedCache 不限制大小，只有当对象过期时才会删除。标准的chache方法不会显式的调用删除(prune)，而是根据定义好的延迟进行定时删除。

public TimedCache(long timeout) {
 this.cacheSize = 0;
 this.timeout = timeout;
 cacheMap = new HashMap<K, CacheObject<K,V>>();
 }

 // ---------------------------------------------------------------- prune

 /**
 * Prunes expired elements from the cache. Returns the number of removed objects.
 */
 @Override
 protected int pruneCache() {
 int count = 0;
 Iterator<CacheObject<K,V>> values = cacheMap.values().iterator();
 while (values.hasNext()) {
 CacheObject co = values.next();
 if (co.isExpired() == true) {
 values.remove();
 count++;
 }
 }
 return count;
 }


 // ---------------------------------------------------------------- auto prune

 protected Timer pruneTimer;

 /**
 * Schedules prune.
 */
 public void schedulePrune(long delay) {
 if (pruneTimer != null) {
 pruneTimer.cancel();
 }
 pruneTimer = new Timer();
 pruneTimer.schedule(
 new TimerTask() {
 @Override
 public void run() {
 prune();
 }
 }, delay, delay
 );
 }

 /**
 * Cancels prune schedules.
 */
 public void cancelPruneSchedule() {
 if (pruneTimer != null) {
 pruneTimer.cancel();
 pruneTimer = null;
 }
 }

注意，还提供了一个FileLFUCache，

没有继承AbstractCacheMap.用LFU将文件缓存到内存，极大加快访问常用文件的性能。

 protected final LFUCache<File, byte[]> cache;
 protected final int maxSize;
 protected final int maxFileSize;

 protected int usedSize;

 /**
 * Creates file LFU cache with specified size. Sets
 * {@link #maxFileSize max available file size} to half of this value.
 */
 public FileLFUCache(int maxSize) {
 this(maxSize, maxSize / 2, 0);
 }

 public FileLFUCache(int maxSize, int maxFileSize) {
 this(maxSize, maxFileSize, 0);
 }

 /**
 * Creates new File LFU cache.
 * @param maxSize total cache size in bytes
 * @param maxFileSize max available file size in bytes, may be 0
 * @param timeout timeout, may be 0
 */
 public FileLFUCache(int maxSize, int maxFileSize, long timeout) {
 this.cache = new LFUCache<File, byte[]>(0, timeout) {
 @Override
 public boolean isFull() {
 return usedSize > FileLFUCache.this.maxSize;
 }

 @Override
 protected void onRemove(File key, byte[] cachedObject) {
 usedSize -= cachedObject.length;
 }

 };
 this.maxSize = maxSize;
 this.maxFileSize = maxFileSize;
 }

 // ---------------------------------------------------------------- get

 /**
 * Returns max cache size in bytes.
 */
 public int getMaxSize() {
 return maxSize;
 }

 /**
 * Returns actually used size in bytes.
 */
 public int getUsedSize() {
 return usedSize;
 }

 /**
 * Returns maximum allowed file size that can be added to the cache.
 * Files larger than this value will be not added, even if there is
 * enough room.
 */
 public int getMaxFileSize() {
 return maxFileSize;
 }

 /**
 * Returns number of cached files.
 */
 public int getCachedFilesCount() {
 return cache.size();
 }

 /**
 * Returns timeout.
 */
 public long getCacheTimeout() {
 return cache.getCacheTimeout();
 }

 /**
 * Clears the cache.
 */
 public void clear() {
 cache.clear();
 usedSize = 0;
 }

 // ---------------------------------------------------------------- get

 public byte[] getFileBytes(String fileName) throws IOException {
 return getFileBytes(new File(fileName));
 }

 /**
 * Returns cached file bytes.
 */
 public byte[] getFileBytes(File file) throws IOException {
 byte[] bytes = cache.get(file);
 if (bytes != null) {
 return bytes;
 }

 // add file
 bytes = FileUtil.readBytes(file);

 if ((maxFileSize != 0) && (file.length() > maxFileSize)) {
 // don't cache files that size exceed max allowed file size
 return bytes;
 }

 usedSize += bytes.length;

 // put file into cache
 // if used size > total, purge() will be invoked
 cache.put(file, bytes);

 return bytes;
 }