简单的java缓存实现(LRU,LFU,FIFO)

原帖地址：http://my.oschina.net/u/866190/blog/188712

提到缓存，不得不提就是缓存算法(淘汰算法)，常见算法有LRU、LFU和FIFO等算法，每种算法各有各的优势和缺点及适应环境。

1、LRU(Least Recently Used ，最近最少使用)

算法根据数据的最近访问记录来淘汰数据，其原理是如果数据最近被访问过，将来被访问的几概率相对比较高，最常见的实现是使用一个链表保存缓存数据，详细具体算法如下：

1. 新数据插入到链表头部；

2. 每当缓存数据命中，则将数据移到链表头部；

3. 当链表满的时候，将链表尾部的数据丢弃；

2、LFU(Least Frequently Used，最不经常使用)

算法根据数据的历史访问频率来淘汰数据，其原理是如果数据过去被访问次数越多，将来被访问的几概率相对比较高。LFU的每个数据块都有一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。

具体算法如下：

1. 新加入数据插入到队列尾部（因为引用计数为1）；

2. 队列中的数据被访问后，引用计数增加，队列重新排序；

3. 当需要淘汰数据时，将已经排序的列表最后的数据块删除；

3、FIFO(First In First Out ，先进先出)

算法是根据先进先出原理来淘汰数据的，实现上是最简单的一种,具体算法如下：

1. 新访问的数据插入FIFO队列尾部，数据在FIFO队列中顺序移动；

2. 淘汰FIFO队列头部的数据；

评价一个缓存算法好坏的标准主要有两个，一是命中率要高，二是算法要容易实现。当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命中率急剧下降，缓存污染情况比较严重。LFU效率要优于LRU，且能够避免周期性或者偶发性的操作导致缓存命中率下降的问题。但LFU需要记录数据的历史访问记录，一旦数据访问模式改变，LFU需要更长时间来适用新的访问模式，即：LFU存在历史数据影响将来数据的“缓存污染”效用。FIFO虽然实现很简单，但是命中率很低，实际上也很少使用这种算法。

基于现有jdk类库，我们可以很容易实现上面的缓存算法

首先定义缓存接口类

[java] view
plaincopy





/**

* 缓存接口

* @author Wen

*

*/

public interface Cache<K,V> {

/**

* 返回当前缓存的大小

*

* @return

*/

int size();

/**

* 返回默认存活时间

*

* @return

*/

long getDefaultExpire();

/**

* 向缓存添加value对象,其在缓存中生存时间为默认值

*

* @param key

* @param value

*/

void put(K key ,V value) ;

/**

* 向缓存添加value对象,并指定存活时间

* @param key

* @param value

* @param expire 过期时间

*/

void put(K key ,V value , long expire ) ;

/**

* 查找缓存对象

* @param key

* @return

*/

V get(K key);

/**

* 淘汰对象

*

* @return 被删除对象大小

*/

int eliminate();

/**

* 缓存是否已经满

* @return

*/

boolean isFull();

/**

* 删除缓存对象

*

* @param key

*/

void remove(K key);

/**

* 清除所有缓存对象

*/

void clear();

/**

* 返回缓存大小

*

* @return

*/

int getCacheSize();

/**

* 缓存中是否为空

*/

boolean isEmpty();

}

基本实现抽象类

[java] view
plaincopy





import java.util.Map;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**

* 默认实现

*/

public abstract class AbstractCacheMap<K,V> implements Cache<K,V> {

class CacheObject<K2,V2> {

CacheObject(K2 key, V2 value, long ttl) {

this.key = key;

this.cachedObject = value;

this.ttl = ttl;

this.lastAccess = System.currentTimeMillis();

}

final K2 key;

final V2 cachedObject;

long lastAccess; // 最后访问时间

long accessCount; // 访问次数

long ttl; // 对象存活时间(time-to-live)

boolean isExpired() {

if (ttl == 0) {

return false;

}

return lastAccess + ttl < System.currentTimeMillis();

}

V2 getObject() {

lastAccess = System.currentTimeMillis();

accessCount++;

return cachedObject;

}

}

protected Map<K,CacheObject<K,V>> cacheMap;

private final ReentrantReadWriteLock cacheLock = new ReentrantReadWriteLock();

private final Lock readLock = cacheLock.readLock();

private final Lock writeLock = cacheLock.writeLock();

protected int cacheSize; // 缓存大小 , 0 -> 无限制

protected boolean existCustomExpire ; //是否设置默认过期时间

public int getCacheSize() {

return cacheSize;

}

protected long defaultExpire; // 默认过期时间, 0 -> 永不过期

public AbstractCacheMap(int cacheSize ,long defaultExpire){

this.cacheSize = cacheSize ;

this.defaultExpire = defaultExpire ;

}

public long getDefaultExpire() {

return defaultExpire;

}

protected boolean isNeedClearExpiredObject(){

return defaultExpire > 0 || existCustomExpire ;

}

public void put(K key, V value) {

put(key, value, defaultExpire );

}

public void put(K key, V value, long expire) {

writeLock.lock();

try {

CacheObject<K,V> co = new CacheObject<K,V>(key, value, expire);

if (expire != 0) {

existCustomExpire = true;

}

if (isFull()) {

eliminate() ;

}

cacheMap.put(key, co);

}

finally {

writeLock.unlock();

}

}

/**

* {@inheritDoc}

*/

public V get(K key) {

readLock.lock();

try {

CacheObject<K,V> co = cacheMap.get(key);

if (co == null) {

return null;

}

if (co.isExpired() == true) {

cacheMap.remove(key);

return null;

}

return co.getObject();

}

finally {

readLock.unlock();

}

}

public final int eliminate() {

writeLock.lock();

try {

return eliminateCache();

}

finally {

writeLock.unlock();

}

}

/**

* 淘汰对象具体实现

*

* @return

*/

protected abstract int eliminateCache();

public boolean isFull() {

if (cacheSize == 0) {//o -> 无限制

return false;

}

return cacheMap.size() >= cacheSize;

}

public void remove(K key) {

writeLock.lock();

try {

cacheMap.remove(key);

}

finally {

writeLock.unlock();

}

}

public void clear() {

writeLock.lock();

try {

cacheMap.clear();

}

finally {

writeLock.unlock();

}

}

public int size() {

return cacheMap.size();

}

public boolean isEmpty() {

return size() == 0;

}

}

LRU缓存实现类

[html] view
plaincopy





import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

/**

* LRU 实现

* @author Wen

*

* @param <K>

* @param <V>

*/

public class LRUCache<K, V> extends AbstractCacheMap<K, V> {

public LRUCache(int cacheSize, long defaultExpire) {

super(cacheSize , defaultExpire) ;

//linkedHash已经实现LRU算法 是通过双向链表来实现，当某个位置被命中，通过调整链表的指向将该位置调整到头位置，新加入的内容直接放在链表头，如此一来，最近被命中的内容就向链表头移动，需要替换时，链表最后的位置就是最近最少使用的位置

this.cacheMap = new LinkedHashMap<K, CacheObject<K, V>>( cacheSize +1 , 1f,true ) {

@Override

protected boolean removeEldestEntry(

Map.Entry<K, CacheObject<K, V>> eldest) {

return LRUCache.this.removeEldestEntry(eldest);

}

};

}

private boolean removeEldestEntry(Map.Entry<K, CacheObject<K, V>> eldest) {

if (cacheSize == 0)

return false;

return size() > cacheSize;

}

/**

* 只需要实现清除过期对象就可以了,linkedHashMap已经实现LRU

*/

@Override

protected int eliminateCache() {

if(!isNeedClearExpiredObject()){ return 0 ;}

Iterator<CacheObject<K, V>> iterator = cacheMap.values().iterator();

int count = 0 ;

while(iterator.hasNext()){

CacheObject<K, V> cacheObject = iterator.next();

if(cacheObject.isExpired() ){

iterator.remove();

count++ ;

}

}

return count;

}

}

LFU实现类

[java] view
plaincopy





import java.util.HashMap;

import java.util.Iterator;

//LFU实现

public class LFUCache<K,V> extends AbstractCacheMap<K, V> {

public LFUCache(int cacheSize, long defaultExpire) {

super(cacheSize, defaultExpire);

cacheMap = new HashMap<K, CacheObject<K,V>>(cacheSize+1) ;

}

/**

* 实现删除过期对象 和 删除访问次数最少的对象

*

*/

@Override

protected int eliminateCache() {

Iterator<CacheObject<K, V>> iterator = cacheMap.values().iterator();

int count = 0 ;

long minAccessCount = Long.MAX_VALUE ;

while(iterator.hasNext()){

CacheObject<K, V> cacheObject = iterator.next();

if(cacheObject.isExpired() ){

iterator.remove();

count++ ;

continue ;

}else{

minAccessCount = Math.min(cacheObject.accessCount , minAccessCount) ;

}

}

if(count > 0 ) return count ;

if(minAccessCount != Long.MAX_VALUE ){

iterator = cacheMap.values().iterator();

while(iterator.hasNext()){

CacheObject<K, V> cacheObject = iterator.next();

cacheObject.accessCount -= minAccessCount ;

if(cacheObject.accessCount <= 0 ){

iterator.remove();

count++ ;

}

}

}

return count;

}

}

FIFO实现类

[java] view
plaincopy





import java.util.Iterator;

import java.util.LinkedHashMap;

/**

* FIFO实现

* @author Wen

*

* @param <K>

* @param <V>

*/

public class FIFOCache<K, V> extends AbstractCacheMap<K, V> {

public FIFOCache(int cacheSize, long defaultExpire) {

super(cacheSize, defaultExpire);

cacheMap = new LinkedHashMap<K, CacheObject<K, V>>(cacheSize + 1);

}

@Override

protected int eliminateCache() {

int count = 0;

K firstKey = null;

Iterator<CacheObject<K, V>> iterator = cacheMap.values().iterator();

while (iterator.hasNext()) {

CacheObject<K, V> cacheObject = iterator.next();

if (cacheObject.isExpired()) {

iterator.remove();

count++;

} else {

if (firstKey == null)

firstKey = cacheObject.key;

}

}

if (firstKey != null && isFull()) {//删除过期对象还是满,继续删除链表第一个

cacheMap.remove(firstKey);

}

return count;

}

}