jodd-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;
    }