(转)学习：一个并发的Cache

public class Memoizer implements Computable {
    private final ConcurrentMap> cache
        = new ConcurrentHashMap>();
    private final Computable c;

    public Memoizer(Computable c) { this.c = c; }

    public V compute(final A arg) throws InterruptedException {
        while (true) {
            Future f = cache.get(arg);
            if (f == null) {
                Callable eval = new Callable() {
                    public V call() throws InterruptedException {
                        return c.compute(arg);
                    }
                };
                FutureTask ft = new FutureTask(eval);
                f = cache.putIfAbsent(arg, ft); //先把FutureTask放进去再说
                if (f == null) { f = ft; ft.run(); } //开始计算
            }
            try {
                return f.get();
            } catch (CancellationException e) {
                cache.remove(arg, f);
            } catch (ExecutionException e) {
                throw launderThrowable(e.getCause());
            }
        }
    }
}

 这个Cache的设计很有意思, 考虑了很多并发的因素. Cache用简单的Map方式来实现.

1) 使用ConcurrentHashMap来存放计算结果
2) 最有趣的一点, ConcurrentHashMap 里存放的内容是 FutureTask. (为什么? 这相当于放一个Latch)
3) 使用了FutureTask来调度计算, 这样多个线程可以分别进行针对不同的参数的计算
4) 基于FutureTask的特性, 先把FutureTask放进了cache, 再对FutureTask计算
5) 用了一个 while(true) 无限循环…
（为什么? 因为如果发现已经有一个线程中进行相同的计算的话, 就直接等待计算结果. 但是等待过程中, 如果FutureTask被中断了呢? 抓住异常, 再等…）
6) 使用putIfAbsent操作, 避免出现两个线程都进行相同的计算