高效可伸缩的结果缓存

1. /** 
2.  * 要执行的算法，返回结果v 
3.  */  
4. public interface Computable<A, V> {  
5.     public V comput(final A arg);  
6.   
7. }  

 

Java代码  

1. /** 
2.  * 用于缓存数据 
3.  */  
4. public class Memoizer<A, V> implements Computable<A, V> {  
5.   
6.     private final ConcurrentMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();  
7.   
8.     private final Computable<A, V> c;  
9.   
10.     private Memoizer(Computable<A, V> c) {  
11.         this.c = c;  
12.     }  
13.   
14.     @Override  
15.     public V comput(final A arg) {  
16.         while (true) {  
17.             Future<V> f = cache.get(arg);  
18.             if (f == null) {  
19.                 Callable<V> eval = new Callable<V>() {  
20.   
21.                     @Override  
22.                     public V call() throws Exception {  
23.                         return c.comput(arg);  
24.                     }  
25.                 };  
26.                 FutureTask<V> ft = new FutureTask<V>(eval);  
27.                 //若没有这个key则put。总是返回oldValue  
28.                 f = cache.putIfAbsent(arg, ft);  
29.                 if (f == null) {  
30.                     f = ft;  
31.                     ft.run();  
32.                 }  
33.   
34.             }  
35.             return null;  
36.         }  
37.     }  
38.   
39. }  

你看懂了吗？