背景
构建一个高效且可伸缩的结果缓存,从多个方案中分析优缺点并最终搞一个最佳实践
前置内容说明
public interface Computable <A,V>{
V compute(A arg) throws InterruptedException;
}
public class ExpensiveFunction implements Computable<String, BigInteger> {
@Override
public BigInteger compute(String arg) throws InterruptedException {
//经过较长时间计算后的操作
return new BigInteger(arg);
}
}
目的:将创建一个Computable包装器,帮助记住之前的计算结果,并将缓存过程封装起来。
1、使用HashMap和同步机制来初始化缓存
public class Memoizer1<A,V> implements Computable<A,V> {
private final Map<A,V> cache = new HashMap<A,V>();
private Computable<A,V> mComputable;
public Memoizer1(Computable<A,V> computable){
mComputable=computable;
}
@Override
public synchronized V compute(A arg) throws InterruptedException {
V result = cache.get(arg);
if(result==null){
result=mComputable.compute(arg);
cache.put(arg,result);
}
return result;
}
}
缺点:
hashMap不是线程安全的,所以对整个方法进行了同步;这种方法能确保线程安全性,但是会带来一个明显 的可伸缩性问题,每次只有一个线程能够执compute如果有多个线程在排队等待还未计算出的结果,那么compute方法的计算时间可能比没有缓存操作的计算时间更长
2、使用ConcurrentHashMap处理并发
public class Memoizer2<A,V> implements Computable<A,V> {
private final Map<A,V> cache = new ConcurrentHashMap<>();
private Computable<A,V> mComputable;
public Memoizer2(Computable<A,V> computable){
mComputable=computable;
}
@Override
public V compute(A arg) throws InterruptedException {
V result = cache.get(arg);
if(result==null){
result=mComputable.compute(arg);
cache.put(arg,result);
}
return result;
}
}
缺点:
相比Memoizer1,Memoizer2对compute去掉了方法同步,并且使用ConcurrentHashMap替代了HashMap; 不足之处在于当两个线程同时掉用compute时存在一个漏洞,可能会导致计算得到相同的值,这种情况特别时对于单次初始化的对象缓存来说,风险更大其次时某个线程启动了一个开销很大的计算,而其它线程并不知道这个计算正在进行,那么很可能会重复这个计算
3、FutureTask处理单个线程开销大时,其它线程不知道计算正在进行
public class Memoizer3<A, V> implements Computable<A, V> {
private final Map<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
private Computable<A, V> mComputable;
public Memoizer3(Computable<A, V> computable) {
mComputable = computable;
}
@Override
public V compute(final A arg) throws InterruptedException {
Future<V> result = cache.get(arg);
if (result == null) {
Callable<V> callable = new Callable<V>() {
@Override
public V call() throws Exception {
return mComputable.compute(arg);
}
};
FutureTask<V> task = new FutureTask<>(callable);
result = task;
cache.put(arg, result);
task.run();
}
try {
return result.get();
} catch (ExecutionException e) {
e.printStackTrace();
throw new InterruptedException(e.getMessage());
}
}
}
缺点:
当前表现出了非常好的并发性,若结果已经计算出来,那么将立即返回;如果其它线程在计算结果,那么新到的线程将一直等待这个结果被计算出来;仍然有一个缺陷,即仍然存在两个线程计算出相同值的漏洞;是由于compute方法中if代码块仍然时非原子的先检查再执行操作符合操作(若没有则添加)是在底层的Map对象上执行的,而这个对象无法通过加锁来确保原子性
4、Future+ConcurrentMap中的原子方法putIfAbsent
最佳方案
public class Memoizer4<A, V> implements Computable<A, V> {
private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();
private final Computable<A, V> mComputable;
public Memoizer4(Computable<A, V> computable) {
mComputable = computable;
}
@Override
public V compute(final A arg) throws InterruptedException {
while (true) {
Future<V> result = cache.get(arg);
if (result == null) {
Callable<V> callable = new Callable<V>() {
@Override
public V call() throws Exception {
return mComputable.compute(arg);
}
};
FutureTask<V> task = new FutureTask<>(callable);
result = cache.putIfAbsent(arg, task);
if (result == null) {
result = task;
task.run();
}
}
try {
return result.get();
} catch (CancellationException e) {
//当缓存的是Future而不是值时,将导致缓存污染问题,计算失败或者取消,需要将Future移除
cache.remove(arg, result);
} catch (ExecutionException exception) {
exception.printStackTrace();
}
}
}
}
备注:参考【Java并发编程实践】