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

壹頁書發表於2015-08-25
快取
JAVA併發程式設計實踐
第85頁

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

第一版 synchronized 控制併發

  1. import java.math.BigInteger;
  2. import java.util.HashMap;
  3. import java.util.Map;

  5. interface Computable<A, V> {
  6.     V compute(A arg) throws InterruptedException;
  7. }

  9. class ExpensiveFunction implements Computable<String, BigInteger> {
  10.     @Override
  11.     public BigInteger compute(String arg) throws InterruptedException {
  12.         return new BigInteger(arg);
  13.     }
  14. }

  16. class Memoizer1<A, V> implements Computable<A, V> {
  17.     private final Map<A, V> cache = new HashMap<A, V>();
  18.     private final Computable<A, V> c;

  20.     public Memoizer1(Computable<A, V> c) {
  21.         this.c = c;
  22.     }

  24.     @Override
  25.     public synchronized V compute(A arg) throws InterruptedException {
  26.         V result = cache.get(arg);
  27.         if (result == null) {
  28.             result = c.compute(arg);
  29.             cache.put(arg, result);
  30.         }
  31.         return result;

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

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



第二版 ConcurrentHashMap替換HashMap

  1. import java.math.BigInteger;
  2. import java.util.Map;
  3. import java.util.concurrent.ConcurrentHashMap;

  5. interface Computable<A, V> {
  6.     V compute(A arg) throws InterruptedException;
  7. }

  9. class ExpensiveFunction implements Computable<String, BigInteger> {
  10.     @Override
  11.     public BigInteger compute(String arg) throws InterruptedException {
  12.         return new BigInteger(arg);
  13.     }
  14. }

  16. class Memoizer2<A, V> implements Computable<A, V> {
  17.     private final Map<A, V> cache = new ConcurrentHashMap<A, V>();
  18.     private final Computable<A, V> c;

  20.     public Memoizer2(Computable<A, V> c) {
  21.         this.c = c;
  22.     }

  24.     @Override
  25.     public V compute(A arg) throws InterruptedException {
  26.         V result = cache.get(arg);
  27.         if (result == null) {
  28.             result = c.compute(arg);
  29.             cache.put(arg, result);
  30.         }
  31.         return result;

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

第三版 Future

  1. import java.math.BigInteger;
  2. import java.util.Map;
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ConcurrentHashMap;
  5. import java.util.concurrent.ExecutionException;
  6. import java.util.concurrent.Future;
  7. import java.util.concurrent.FutureTask;

  9. interface Computable<A, V> {
  10.     V compute(final A arg) throws InterruptedException, ExecutionException;
  11. }

  13. class ExpensiveFunction implements Computable<String, BigInteger> {
  14.     @Override
  15.     public BigInteger compute(String arg) throws InterruptedException, ExecutionException {
  16.         return new BigInteger(arg);
  17.     }
  18. }

  20. class Memoizer3<A, V> implements Computable<A, V> {
  21.     private final Map<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
  22.     private final Computable<A, V> c;

  24.     public Memoizer3(Computable<A, V> c) {
  25.         this.c = c;
  26.     }

  28.     @Override
  29.     public V compute(final A arg) throws InterruptedException, ExecutionException {
  30.         Future<V> f = cache.get(arg);
  31.         if (f == null) {
  32.             Callable<V> eval = new Callable<V>() {

  34.                 @Override
  35.                 public V call() throws ExecutionException, InterruptedException {
  36.                     return c.compute(arg);
  37.                 }

  39.             };
  40.             FutureTask<V> ft = new FutureTask<V>(eval);
  41.             f = ft;
  42.             cache.put(arg, ft);
  43.             ft.run();
  44.         }
  45.         return f.get();
  46.     }
  47. }
這個版本的問題是
if(f==null)是非原子的"先檢查後執行",可能會有多個執行緒同時進入該段程式碼.但是相對於第二版,機率已經大大降低.

最終版本

  1. import java.math.BigInteger;
  2. import java.util.Map;
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ConcurrentHashMap;
  5. import java.util.concurrent.ExecutionException;
  6. import java.util.concurrent.Future;
  7. import java.util.concurrent.FutureTask;

  9. interface Computable<A, V> {
  10.     V compute(final A arg) throws InterruptedException;
  11. }

  13. class ExpensiveFunction implements Computable<String, BigInteger> {
  14.     @Override
  15.     public BigInteger compute(String arg) throws InterruptedException {
  16.         return new BigInteger(arg);
  17.     }
  18. }

  20. class Memoizer3<A, V> implements Computable<A, V> {
  21.     private final ConcurrentHashMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
  22.     private final Computable<A, V> c;

  24.     public Memoizer3(Computable<A, V> c) {
  25.         this.c = c;
  26.     }

  28.     @Override
  29.     public V compute(final A arg) throws InterruptedException {
  30.         while (true) {
  31.             Future<V> f = cache.get(arg);
  32.             if (f == null) {
  33.                 Callable<V> eval = new Callable<V>() {
  34.                     public V call() throws InterruptedException {
  35.                         return c.compute(arg);
  36.                     }
  37.                 };

  39.                 FutureTask<V> ft = new FutureTask<V>(eval);
  40.                 f = cache.putIfAbsent(arg, ft);
  41.                 if (f == null) {
  42.                     f = ft;
  43.                     ft.run();
  44.                 }
  45.             }
  46.             try {
  47.                 return f.get();
  48.             } catch (ExecutionException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }
  52.     }
  53. }
這個版本還是有一些問題，比如沒有快取失效機制,並且異常的時候沒有將Future從Map中移除.
不過已經說明了很多的用法.

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

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

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

相關文章