1、使用HashMap实现缓存
代码如下:
/** * Memoizer1 * * Initial cache attempt using HashMap and synchronization * * @author Brian Goetz and Tim Peierls */ public class Memoizer1 <A, V> implements Computable<A, V> { @GuardedBy("this") private final Map<A, V> cache = new HashMap<A, V>(); private final Computable<A, V> c; public Memoizer1(Computable<A, V> c) { this.c = c; } public synchronized V compute(A arg) throws InterruptedException { V result = cache.get(arg); if (result == null) { result = c.compute(arg); cache.put(arg, result); } return result; } } interface Computable <A, V> { V compute(A arg) throws InterruptedException; } class ExpensiveFunction implements Computable<String, BigInteger> { public BigInteger compute(String arg) { // after deep thought... return new BigInteger(arg); } }
使用HashMap存储前面的计算结果,compute方法首先检查期待的结果是否已经在缓存中,如果有则返回之前计算的数值。否则,会进行计算并在返回之前将结果存储在HashMap中。
HashMap不是线程安全的,所以使用synchronized来同步了整个compute方法,一次只能由一个线程可以执行compute。如果正在执行的方法计算结果需要比较长的时间,则其他多个线程需要阻塞等待。
2、使用ConcurrentHashMap取代HashMap。ConcurrentHashMap是线程安全的并发容器,所以不需要额外的解锁操作。
代码如下:
/** * Memoizer2 * <p/> * Replacing HashMap with ConcurrentHashMap * * @author Brian Goetz and Tim Peierls */ public class Memoizer2 <A, V> implements Computable<A, V> { private final Map<A, V> cache = new ConcurrentHashMap<A, V>(); private final Computable<A, V> c; public Memoizer2(Computable<A, V> c) { this.c = c; } public V compute(A arg) throws InterruptedException { V result = cache.get(arg); if (result == null) { result = c.compute(arg); cache.put(arg, result); } return result; } }
但是在多个线程同时调用compute方法是,存在并发问题。第一个进入的线程由于计算时间长,第二个线程进入时,并没有查询到结果,所以也进入计算,这样就产生了重复计算相同的数据的情况。
3、为了能够让之后进入的线程看到已有线程正在执行任务,可以使用FutureTask来作为缓存的值。FutureTask代表了一个计算的过程,可能已经结束,也可能正在运行中。FutureTask.get()只要结果可用,就会立刻将结果返回;否则它会一直阻塞,直到结果被计算出来,并返回。
使用ConcurrentHashMap<A,Future<V>>取代ConcurrentHashMap<A,V>,首先检查一个相应的计算是否已经开始。如果没有,就创建一个FutureTask,把它注册到Map中,并开始计算;如果有,那么久等待正在进行的计算。
代码如下:
/** * Memoizer3 * <p/> * Memoizing wrapper using FutureTask * * @author Brian Goetz and Tim Peierls */ public class Memoizer3 <A, V> implements Computable<A, V> { private final Map<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>(); private final Computable<A, V> c; public Memoizer3(Computable<A, V> c) { this.c = c; } public V compute(final A arg) throws InterruptedException { Future<V> f = cache.get(arg); 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 = ft; cache.put(arg, ft); ft.run(); // call to c.compute happens here } try { return f.get(); } catch (ExecutionException e) { throw LaunderThrowable.launderThrowable(e.getCause()); } } }
这个方式存在于之前实现方式类似的问题,多个线程同时进入compute方法时,由于compute中的if代码块是非原子性的“检查再运行”,可能两个线程几乎在同一时间调用compute计算相同的值,双方都没有在缓存中找到期望的值,并都开始计算。
4、利用ConcurrentHashMap中原子操作putIfAbsent方法,如果没有则放入
代码如下:
/** * Memoizer * <p/> * Final implementation of Memoizer * * @author Brian Goetz and Tim Peierls */ 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); 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()); } } } }