一般cache的做法

public class InforoneCache<K, V> implements Cache<K, V> {

class CacheObject<K2, V2> {
final K2 key;
final V2 value;
long lastModified; // 最后添加时间
long expire; // 对象存活时间

CacheObject(K2 key, V2 value, long expire) {
this.key = key;
this.value = value;
this.lastModified = System.currentTimeMillis();
this.expire = expire;
}

boolean isExpired() {
if (expire == 0) {
return false;
}
return lastModified + expire < System.currentTimeMillis();
}

V2 getObject() {
return value;
}
}

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 TryCache(int cacheSize, long defaultExpire) {
this.cacheSize = cacheSize;
this.defaultExpire = defaultExpire;
cacheMap = new HashMap<K, CacheObject<K, V>>(cacheSize + 1);
}

public long getDefaultExpire() {
return defaultExpire;
}

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

}

static final InforoneCache<String, DatumMining> cache = new InforoneCache<String, DatumMining>(0, 30 * 60 * 1000L);
public getData() {
Xxx xxx = cache.get(key);
if (DatumMining == null) {
...
}
cache.put(key, xxx);
}