1 public class Memoizer4<T,R> implements  Computable<T,R>{
 2 
 3     private  final ConcurrentMap<T,Future> cache = new ConcurrentHashMap<>();
 4 
 5     private  final Computable<T,R> computable;
 6 
 7     public Memoizer4(Computable<T, R> computable) {
 8         this
 
.computable = computable;
 9     }
10 
11     public R compute(final T input) throws InterruptedException {
12         while (true){
13             Future<R> future = cache.get(input);
14             if (future==null){
15                 Callable<R> callable = new Callable<R>() {
16
 
                     @Override
17                     public R call() throws InterruptedException {
18                         return computable.compute(input);
19                     }
20                 };
21                 FutureTask futureTask = new FutureTask(callable);
22                 future= cache.putIfAbsent(input, futureTask);//
 
如果原先不存在，返回null
23                 if(future==null){
24                     future=futureTask;
25                     futureTask.run();
26                 }
27             }
28             try{
29                 return future.get();
30             } catch (CancellationException e) {
31                 cache.remove(input,future);
32             } catch (ExecutionException e) {
33                 throw new RuntimeException(e);
34             }
35         }
36     }