緩存的簡單實現

//此文基於《Java並發編程實踐》

我們都知道在應用程序中合理地使用緩存，能更快的訪問我們之前的計算結果，從而提高吞吐量。例如Redis和Memcached基於內存的數據存儲系統等。此篇文章介紹如何實現簡單緩存。

首先定義一個Computable接口A是輸入，V是輸出。

package simplecache;

/**
 * Created by yulinfeng on 12/25/16.
 */
public interface Computable<A, V> {
    V compute(A arg) throws InterruptedException;
}

實現這個接口，也即是在ExpensiveFunction做具體的計算過程。

package simplecache;

/**
 * Created by yulinfeng on 12/25/16.
 */
public class ExpensiveFunction implements Computable<String, Integer> {
    @Override
    public Integer compute(String arg) throws InterruptedException {
        //計算
        return new Integer(arg);
    }
}

接着將創建一個Computable包裝器，幫助記住之前的計算結果，並將緩存過程封裝起來（Memoization）。

1.利用簡單HashMap實現緩存

package simplecache;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by yulinfeng on 12/25/16.
 */
public 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 compute(A arg) throws InterruptedException {
        V result = cache.get(arg);
        if (null == result){
            result = c.compute(arg);
            cache.put(arg, result);
        }
        return result;
    }
}

我們首先利用最簡單的HashMap實現緩存，由於HashMap並不是線程安全的，所以在compute方法使用synchronized關鍵字，同步以實現線程安全。可見使用synchronized同步方法如此大粒度的同步必然會帶來並發性的降低，因為每次只有一個線程執行compute方法，其余線程只能排隊等待。

2.利用並發容器ConcurrentHashMap

第1種方法能實現緩存，且能實現線程安全的緩存，不過帶來的問題就是並發性降低。我們使用並發包中的ConcurrentHashMap並發容器。

package simplecache;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by yulinfeng on 12/25/16.
 */
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;
    }

    @Override
    public V compute(A arg) throws InterruptedException {
        V result = cache.get(arg);
        if (null == result){
            result = c.compute(arg);
            cache.put(arg, rsult);
        }
        return result;
    }
}

毫無疑問，利用ConcurrentHashMap會比簡單HashMap帶來更好的並發性，同時它也是線程安全的。不過在有一種條件下，這種方式會帶來一個新的問題，當這個計算過程比較復雜，計算時間比較長時，線程T1正在計算沒有結束，此時線程T2並不知道此時T1已經在計算了，所以它同樣會再次進行計算，這種條件下相當於一個值被計算了2次。我們應該想要達到的效果應該是T1正在計算，而此時T2能發現T1正在計算相同值，此時應該阻塞等待T1計算完畢返回計算結果，而不是T2也去做一次計算。FutureTask表示一個計算過程，這個計算過程可能已經計算完成，也有可能正在計算。如果有結果可用，那么FutureTask.get將立即返回結果，否則會一直阻塞直到計算結束返回結果。這正好我們想要達到的效果。

3.緩存的最佳實踐——ConcurrentHashMap+FutureTask

package simplecache;

import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * Created by yulinfeng on 12/25/16.
 */
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;
    }

    @Override
    public V compute(final A arg) throws InterruptedException {
        Future<V> f = cache.get(arg);
        if (null == f){
            Callable<V> eval = new Callable<V>() {
                @Override
                public V call() throws InterruptedException {
                    return c.compute(arg);
                }
            };
            FutureTask<V> ft = new FutureTask<V>(eval);
            cache.put(arg, ft);
            ft.run();   //調用執行c.compute
        }
        try {
            return f.get();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

不了解FutureTask可以去補補了，但記住上面所說“FutureTask表示一個計算過程，這個計算過程可能已經計算完成，也有可能正在計算。如果有結果可用，那么FutureTask.get將立即返回結果，否則會一直阻塞直到計算結束返回結果。”，但這並不算是最完美的實現，在compute方法中出現了if的復合操作，也就是說在期間還是很有可能出現如同ConcurrentHashMap一樣的重復計算，只是概率降低了而已。幸好，ConcurrentHashMap為我們提供了putIfAbsent的原子方法，從而完美的避免了這個問題。

package simplecache;

import java.util.concurrent.*;

/**
 * Created by yulinfeng on 12/25/16.
 */
public class Memoizer<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 Memoizer(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 (null == f) {
                Callable<V> eval = new Callable<V>() {
                    @Override
                    public V call() throws Exception {
                        return c.compute(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<V>(eval);
                f = cache.putIfAbsent(arg, ft);
                if (null == f){
                    f = ft;
                    ft.run();
                }
            }
            try {
                return f.get();
            } catch (CancellationException e){
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

這樣我們利用ConcurrentHashMap的並發性已經putIfAbsent原子性，以及FutureTask的特性實現了一個簡單緩存。