java带timeout的本地缓存实现
最近碰到了本地缓存,查阅了一下资料使用currentHashMap实现了一个带timeout的本地缓存,
直接上代码:
package local.cache;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class LocalCache {
private LocalCache() {
}
// 测试为public,实际使用应该改为private
public static final Map<String, ValueObject> localCache = new ConcurrentHashMap<String, ValueObject>();
static {
// 初始化
// Test
for(int i = 1;i<11;i++) {
System.out.println(LocalCache.set(String.valueOf(i),i +"-value", 3000));
}
}
private static class ValueObject {
private String value;
private long timeout;
private ValueObject(String value, long timeout) {
super();
this.value = value;
this.timeout = timeout;
}
private String getValue() {
return value;
}
private long getTimeout() {
return timeout;
}
}
public static String set(String key, String value, long timeout) {
long currentTime = System.currentTimeMillis();
ValueObject valueObject = localCache.get(key);
if (localCache.keySet().contains(key) && (valueObject.getTimeout() == 0 ||currentTime <= valueObject.getTimeout())) {
return valueObject.getValue();
} else {
ValueObject oldValueObject = localCache.put(key,new ValueObject(value,currentTime + timeout));
return oldValueObject == null ? null : oldValueObject.getValue();
}
}
public static String set(String key, String value) {
ValueObject oldValueObject = localCache.put(key,new ValueObject(value, 0));
return oldValueObject == null ? null : oldValueObject.getValue();
}
public static String get(String key) {
long currentTime = System.currentTimeMillis();
ValueObject valueObject = localCache.get(key);
if (valueObject == null) {
return null;
}
if (valueObject.getTimeout() == 0 || currentTime <= valueObject.getTimeout()) {
return valueObject.getValue().toString();
} else {
localCache.remove(key);
return null;
}
}
}
测试:
package local.cache;
public class Client {
public static void main(String[] args) {
System.out.println(LocalCache.localCache);//为了使static(field,block,method) 运行(初始化),初始化顺序为代码声明的顺序
// 实际使用时只有LocalCache.set和LocalCache.get暴露出来,所以调用这两个方法的时候,localCache和静态块已经先行初始化了
try {
Thread.sleep(3001);// 本来使用的是3000,但是输出有问题,有些预想已经过时的却仍旧能够取得到,估计是jvm运行优化导致的
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i = 1;i < 11;i++) {
System.out.println(i +":"+ LocalCache.get(String.valueOf(i)));
}
}
}
currentHashMap这个实现类在多线程情况下,有一个类似行级读写锁功能,可以另行查阅一下。
所以这个也就实现了并发的安全性。