構建高效且可伸縮的結果快取

JAVA併發程式設計實踐
第85頁

環境 JDK1.6(貌似使用1.7編譯會有問題)

第一版 synchronized 控制併發

ExpensiveFunction 模擬一個很費時間的操作.比如資料庫讀取。

這個版本問題很明顯,就是synchronized 限制了併發.

第二版 ConcurrentHashMap替換HashMap

這個版本的問題是,在併發很高的情況下,一旦快取失效,大量的請求會擁塞資料庫的所有執行緒.造成資料庫的間歇性問題.

第三版 Future

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;
interface Computable<A, V> {
V compute(final A arg) throws InterruptedException, ExecutionException;
}
class ExpensiveFunction implements Computable<String, BigInteger> {
@Override
public BigInteger compute(String arg) throws InterruptedException, ExecutionException {
return new BigInteger(arg);
}
}
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;
}
@Override
public V compute(final A arg) throws InterruptedException, ExecutionException {
Future<V> f = cache.get(arg);
if (f == null) {
Callable<V> eval = new Callable<V>() {
@Override
public V call() throws ExecutionException, InterruptedException {
return c.compute(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
f = ft;
cache.put(arg, ft);
ft.run();
}
return f.get();
}
}

這個版本的問題是
if(f==null)是非原子的"先檢查後執行",可能會有多個執行緒同時進入該段程式碼.但是相對於第二版,概率已經大大降低.

最終版本

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;
interface Computable<A, V> {
V compute(final A arg) throws InterruptedException;
}
class ExpensiveFunction implements Computable<String, BigInteger> {
@Override
public BigInteger compute(String arg) throws InterruptedException {
return new BigInteger(arg);
}
}
class Memoizer3<A, V> implements Computable<A, V> {
private final ConcurrentHashMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
private final Computable<A, V> c;
public Memoizer3(Computable<A, V> c) {
this.c = c;
}
@Override
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 (ExecutionException e) {
e.printStackTrace();
}
}
}
}

這個版本還是有一些問題，比如沒有快取失效機制,並且異常的時候沒有將Future從Map中移除.
不過已經說明了很多的用法.

這個while迴圈感覺很精妙
一旦 return f.get()發生ExecutionException異常,程式碼不會退出,而是會再次執行.

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/29254281/viewspace-1782226/，如需轉載，請註明出處，否則將追究法律責任。

相關文章