java-blog

有一個很耗時的運算需要緩存其計算結果，采用備忘錄模式實現，如：

public interface Computable<A, V> {
V compute(A arg) throws InterruptedException;
}
public class ExpensiveFunction
implements Computable<String, BigInteger> {
public BigInteger compute(String arg) {
// 假設這里非常耗時...
return new BigInteger(arg);
}
}

備忘錄緩存方案一：

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;
}
}

這里備忘錄的整個compute過程被同步，相當于我最原始的低效方案，


備忘錄緩存方案二：

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;
}
}

將線程安全性委給cache，注：這個方案的cache用了ConcurrentHashMap，它是線程安全的。

備忘錄緩存方案三：

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(e.getCause());
}
}
}

使用Future(相當上一帖的Entry)封裝，因為這里資源獲取過程不固定(通用方案)，所以使用了Callable進行回調資源獲取過程(求值)，
這個方案的 if (f == null) 不安全，特殊性可能會進行多次運算，下面的方案四解決這個問題。

備忘錄緩存方案四（最終方案）：