幾乎所有的服務器應用程序都會使用某種形式的緩存。中用之前的計算結果能降低延遲，提高吞吐量，但卻會消耗更多的內存。
這博客記錄一下如果開發一個高效可伸縮的緩存，將從簡單的hashmap開始，然后一步步分析他的性能缺陷，并記錄如何修復這些缺陷。
目標需求
在Computable<A,V>接口中聲明一個函數，Computable，其輸入類型為A，輸出類型為V。在ExpensiveFunction中實現的Computable需要很長的時間結算結果，我們將創建一個Computable的包裝器，幫助記住之前的計算結果，并將緩存過程封裝起來。
實現方式1
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;
public class CacheTest1 {
}
class ExpensiveFunction implements Computable<String, BigInteger>{
@Override
public BigInteger comput(String args) throws InterruptedException {
// 這里是一個計算很長的過程
return new BigInteger(args);
}
}
class Memoizer1<A, V> implements Computable<A, V>{
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;
}
@Override
public synchronized V comput(A arg) throws InterruptedException {
V result=cache.get(arg);
if(result==null){
result=c.comput(arg);
}
return result;
}
}
在上面程序，Memoizer1給出了第一種嘗試，使用HashMap保存之前的計算結果。compute方法檢查需要的結果是否在緩存中，如果存在則把結果返回，否則重新計算然后把結果放到HashMap中。
上面的代碼存在2個問題，1、因為HashMap不是線程安全的，因此需要synchronized進行方法同步，但是這樣做的話同時只能有一個線程執行compute，如果某個線程執行計算的時間很長，那么將會出超時阻塞。2、會造成重復計算，由于計算時間過長，其他的線程并不知道這個計算正在進行，因此會繼續重復計算。
實現方式2
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CacheTest2 {
}
class ExpensiveFunction implements Computable<String, BigInteger>{
@Override
public BigInteger comput(String args) throws InterruptedException {
// do something
return new BigInteger(args);
}
}
class Memoizer1<A, V> implements Computable<A, V>{
private final Map<A,V> cache=new ConcurrentHashMap<A,V>();
private final Computable<A,V> c;
public Memoizer1(Computable<A,V> _c){
this.c=_c;
}
@Override
public V comput(A arg) throws InterruptedException {
V result=cache.get(arg);
if(result==null){
result=c.comput(arg);
}
return result;
}
}
在上面代碼中，將hashmap替換成了concurrnethashmap，由于concurrenthashmap類本身是線程安全的因此在訪問底層map就不需要增加synchronized，因此就避免了compute方法的串行性，提高了并發行為。
雖然上面代碼解決了并發問題，但是依然存在一個問題就是會存在重復計算問題，這種方案依然不夠完美，我們繼續完善，繼續向下看。
實現方式3
import java.math.BigInteger;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class CacheTest3 {
}
class ExpensiveFunction implements Computable<String, BigInteger> {
@Override
public BigInteger comput(String args) throws InterruptedException {
// do something
return new BigInteger(args);
}
}
class Memoizer1<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 Memoizer1(Computable<A, V> _c) {
this.c = _c;
}
@Override
public V comput(A arg) throws InterruptedException {
Future<V> f = cache.get(arg);
if (f == null) {
Callable<V> eval = new Callable<V>() {
@Override
public V call() throws Exception {
return c.comput(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
f = ft;
cache.put(arg, ft);
ft.run();
}
V v=null;
try {
v=f.get();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return v;
}
}
上面代碼使用了futuretask，futuretask表示一個計算的過程，這個過程可能已經計算完成，也可能正在進行。如果結果可用，那么futuretask.get將立刻返回結果，否則它會一直阻塞，知道有結果在返回。
在comput函數中，會先從cache中獲得當前計算內容是否在計算，如果沒有在計算，那么創建一個FutureTask放到map中，然后啟動這個計算；如果有在計算則直接調用get等待返回結果。
上面的方案其實已經很完美了，它表現出了非常好的并發特性，但是還是存在一點小小的缺陷，在高并發狀態下，仍然會存在重復計算問題。問題的根本原因就是在if的代碼塊中是非原子的“先檢查在執行”操作，因此兩個線程仍有可能在同一時間調用compute計算相同的值。
最終實現
import java.math.BigInteger;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class CacheTest3 {
}
class ExpensiveFunction implements Computable<String, BigInteger> {
@Override
public BigInteger comput(String args) throws InterruptedException {
// do something
return new BigInteger(args);
}
}
class Memoizer1<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 Memoizer1(Computable<A, V> _c) {
this.c = _c;
}
@Override
public V comput(A arg) throws InterruptedException {
Future<V> f = cache.get(arg);
if (f == null) {
Callable<V> eval = new Callable<V>() {
@Override
public V call() throws Exception {
return c.comput(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
f=cache.putIfAbsent(arg, ft);
if(f==null){
f=ft;
ft.run();
}
}
V v=null;
try {
v=f.get();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return v;
}
}
實現方式3中存在的問題是復合操作實在底層的map對象上執行的，而這個對象無法通過加鎖來保持原子性。在最終實現中使用了concurrnethashmap中的原子方法putifabsent，避免了重復計算問題。
