支持并发的结果缓存

改自《Java Concurrency in Practice》Listing 5.19. Final Implementation of Memoizer.
比我之前自己写的好多了，必备工具类，记下来留着以后常用

特点：
1.使用Future与ConcurrentMap#putIfAbsent(K key, V value)避免了多个线程重复计算
2.如果计算被取消或失败，会调用ConcurrentMap#remove(key, future)来避免Cache Pollution

Java代码  

1. public interface Computable<K, V> {   
2.     V compute(final K key) throws InterruptedException;   
3. }  

public interface Computable<K, V> {V compute(final K key) throws InterruptedException;}

 

Java代码  

1. public class ConcurrentCache<K, V> implements Computable<K, V> {   
2.   
3.     private static final int DEFAULT_INITIAL_CAPACITY = 16;   
4.     private static final int DEFAULT_CONCURRENCY_LEVEL = 16;   
5.     private static final float DEFAULT_LOAD_FACTOR = 0.75f;   
6.   
7.     private final ConcurrentMap<K, Future<V>> cache;   
8.     private final Computable<K, V> computable;   
9.   
10.     public ConcurrentCache(Computable<K, V> computable) {   
11.         this(computable, DEFAULT_INITIAL_CAPACITY, DEFAULT_CONCURRENCY_LEVEL);   
12.     }   
13.   
14.     public ConcurrentCache(Computable<K, V> computable, int initialCapacity, int concurrencyLevel) {   
15.         this(computable, initialCapacity, DEFAULT_LOAD_FACTOR, concurrencyLevel);   
16.     }   
17.   
18.     public ConcurrentCache(Computable<K, V> computable, int initialCapacity, float loadFactor, int concurrencyLevel) {   
19.         this.computable = computable;   
20.         cache = new ConcurrentHashMap<K, Future<V>>(initialCapacity, loadFactor, concurrencyLevel);   
21.     }   
22.   
23.     @Override  
24.     public V compute(final K key) throws InterruptedException {   
25.         while (true) {   
26.             Future<V> future = cache.get(key);   
27.             if (future == null) {   
28.                 FutureTask<V> futureTask = new FutureTask<V>(new Callable<V>() {   
29.   
30.                     @Override  
31.                     public V call() throws Exception {   
32.                         return computable.compute(key);   
33.                     }   
34.                 });   
35.   
36.                 /**  
37.                  * V putIfAbsent(K key, V value)  
38.                  * 等效于以下代码，只不过以原子操作的方式执行  
39.                  * if (!map.containsKey(key))  
40.                  *      return map.put(key, value); 
41.                  * else  
42.                  *      return map.get(key);  
43.                  */  
44.                 future = cache.putIfAbsent(key, futureTask);   
45.                 if (future == null) {   
46.                     future = futureTask;   
47.                     futureTask.run();   
48.                 }   
49.             }   
50.             try {   
51.                 return future.get();   
52.             } catch (InterruptedException e) {   
53.                 /**  
54.                  * boolean remove(Object key, Object value) 
55.                  * 等效于以下代码，只不过以原子操作的方式执行  
56.                  * if (map.containsKey(key) && map.get(key).equals(value)) { 
57.                  *      map.remove(key);  
58.                  *      return true;  
59.                  * } else {  
60.                  *      return false;  
61.                  * }  
62.                  */  
63.                 cache.remove(key, future);   
64.                 throw e;   
65.             } catch (CancellationException e) {   
66.                 cache.remove(key, future);   
67.             } catch (ExecutionException e) {   
68.                 cache.remove(key, future);   
69.                 throw new RuntimeException(e.getCause());   
70.             } catch (RuntimeException e) {   
71.                 cache.remove(key, future);   
72.                 throw e;   
73.             }   
74.         }   
75.     }   
76. }  

public class ConcurrentCache<K, V> implements Computable<K, V> {private static final int DEFAULT_INITIAL_CAPACITY = 16;private static final int DEFAULT_CONCURRENCY_LEVEL = 16;private static final float DEFAULT_LOAD_FACTOR = 0.75f;private final ConcurrentMap<K, Future<V>> cache;private final Computable<K, V> computable;public ConcurrentCache(Computable<K, V> computable) {this(computable, DEFAULT_INITIAL_CAPACITY, DEFAULT_CONCURRENCY_LEVEL);}public ConcurrentCache(Computable<K, V> computable, int initialCapacity, int concurrencyLevel) {this(computable, initialCapacity, DEFAULT_LOAD_FACTOR, concurrencyLevel);}public ConcurrentCache(Computable<K, V> computable, int initialCapacity, float loadFactor, int concurrencyLevel) {this.computable = computable;cache = new ConcurrentHashMap<K, Future<V>>(initialCapacity, loadFactor, concurrencyLevel);}@Overridepublic V compute(final K key) throws InterruptedException {while (true) {Future<V> future = cache.get(key);if (future == null) {FutureTask<V> futureTask = new FutureTask<V>(new Callable<V>() {@Overridepublic V call() throws Exception {return computable.compute(key);}});/** * V putIfAbsent(K key, V value) * 等效于以下代码，只不过以原子操作的方式执行 * if (!map.containsKey(key)) * return map.put(key, value); * else * return map.get(key); */future = cache.putIfAbsent(key, futureTask);if (future == null) {future = futureTask;futureTask.run();}}try {return future.get();} catch (InterruptedException e) {/** * boolean remove(Object key, Object value) * 等效于以下代码，只不过以原子操作的方式执行 * if (map.containsKey(key) && map.get(key).equals(value)) { * map.remove(key); * return true; * } else { * return false; * } */cache.remove(key, future);throw e;} catch (CancellationException e) {cache.remove(key, future);} catch (ExecutionException e) {cache.remove(key, future);throw new RuntimeException(e.getCause());} catch (RuntimeException e) {cache.remove(key, future);throw e;}}}}