FutureTask实现高效缓存

package learnthread.ftask;

public interface Computable<A, V> {
    /**
     * 计算函数
     * 
     * @param args
     * @return
     * @throws Exception
     */
    public V compute(final A args) throws Exception;

}

package learnthread.ftask;

import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Memorizer<A, V> implements Computable<A, V> {
    private final ConcurrentHashMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
    private final Computable<A, V> c;

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

    @Override
    public V compute(final A args) throws Exception {
        Future<V> f = cache.get(args);
        if (f == null) {
            Callable<V> eval = new Callable<V>() {

                @Override
                public V call() throws Exception {
                    // TODO Auto-generated method stub
                    return c.compute(args);
                }
            };
            FutureTask<V> ft = new FutureTask<>(eval);
            f = ft;
            cache.put(args, f);
            ft.run();
        }
        try {
            return f.get();
        } catch (InterruptedException | ExecutionException e) {
            throw e;
        }

    }
}