java并发编程实战-构建高效且可伸缩的结果缓存

public class CacheSample<IN, OUT> {
/*
* 缓存类容器
* 1，选择线程安全的ConcurrentMap，它提供了并发读写的线程安全，以及“先检查再执行”这样的原子操作putIfAbsent
* 2，选择Future，避免直接存储计算结果值，导致高并发下多个线程同时计算同一个值的情况
*/
private final ConcurrentMap<IN, Future<OUT>> cache = new ConcurrentHashMap<IN, Future<OUT>>();

public OUT doSomething(final IN arg) throws InterruptedException {
while (true) {
Future<OUT> f = cache.get(arg);
if (f == null) {
// 如果没有IN对应的Future，则创建Future
Callable<OUT> eval = new Callable<OUT>() {
public OUT call() throws InterruptedException {
return doing(arg);
}
};
FutureTask<OUT> ft = new FutureTask<OUT>(eval);
// 通过putIfAbsent完成“先检查再添加”的原子操作
// putIfAbsent如果已存在则返回已存在的值，如果不存在则添加新建的Future并返回null
f = cache.putIfAbsent(arg, ft);
if (f == null) {
// 如果新添加进缓存，则启动计算
f = ft;
ft.run();
}
}
try {
// 不管f是新创建的还是通过缓存中获取的，如果Future还没计算结束就阻塞，如果计算结束就获取值
return f.get();
} catch (CancellationException e) {
// 当某个计算被取消或者失败，需要从缓存中移除该IN及对应的Future
// 否则，将持续性获取不到正确的值，但同时又无法再进行新的计算（缓存污染）
cache.remove(arg, f);
} catch (ExecutionException e) {
throw LaunderThrowable.launderThrowable(e.getCause());
}
}
}

private OUT doing(final IN arg){
// 非常耗时的处理过程................
return null;
}
}