构建高效且可伸缩的结果缓存

public class Memoizer <A, V> implements Computable<A, V> {
    private final ConcurrentMap<A, Future<V>> cache
            = new ConcurrentHashMap<A, Future<V>>();//实现高效并发
    private final Computable<A, V> c;


    public Memoizer(Computable<A, V> c) {
        this.c = c;
    }


    public V compute(final A arg) throws InterruptedException {
        while (true) {
            Future<V> f = cache.get(arg);//避免重复计算 若其他线程在计算f的结果，那么新到的线程将一直等待这个结果被计算出来
            if (f == null) {
                Callable<V> eval = new Callable<V>() {
                    public V call() throws InterruptedException {
                        return c.compute(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<V>(eval);
                f = cache.putIfAbsent(arg, ft);//保证原子操作，避免计算相同值
                if (f == null) {
                    f = ft;
                    ft.run();
                }
            }
            try {
                return f.get();
            } catch (CancellationException e) {
                cache.remove(arg, f);
            } catch (ExecutionException e) {
                throw LaunderThrowable.launderThrowable(e.getCause());
            }
        }
    }
}

案例：如果Servlet在对某个大数值进行因数分解时需要很长的执行时间，那么其他客户端必须一直等待，直到Servlet处理完当前的请求，才能开始另一个新的因数分解运算。这背离了Servlet能处理多个请求的初衷。

解决方案：使用可并发且保证原子操作的缓存机制

@ThreadSafe
public class Factorizer extends GenericServlet implements Servlet {
    private final Computable<BigInteger, BigInteger[]> c =
            new Computable<BigInteger, BigInteger[]>() {
                public BigInteger[] compute(BigInteger arg) {
                    return factor(arg);
                }
            };
    private final Computable<BigInteger, BigInteger[]> cache
            = new Memoizer<BigInteger, BigInteger[]>(c);


    public void service(ServletRequest req,
                        ServletResponse resp) {
        try {
            BigInteger i = extractFromRequest(req);
            encodeIntoResponse(resp, cache.compute(i));
        } catch (InterruptedException e) {
            encodeError(resp, "factorization interrupted");
        }
    }


    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }


    void encodeError(ServletResponse resp, String errorString) {
    }


    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }


    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[]{i};
    }
}