Java並發，看到了，就記錄下唄

在這篇博客中，主要把之前看的書的內容記錄一下，個人感覺還是可以的，原題是這樣的：開發一個高效的緩存。這里指的是單機.

首先我來看當前的一個版本

public interface Computable<T, R> {
    R compute(T input) throws InterruptedException;
}

public class Memoizer1<T,R> implements  Computable<T,R>{

    private  final Map<T,R> cache = new HashMap<>();

    private  final Computable<T,R> computable;

    public Memoizer1(Computable<T, R> computable) {
        this.computable = computable;
    }

    public synchronized R compute(T input) throws InterruptedException {
        R result= cache.get(input);
        if(result ==null){
            result = computable.compute(input);
            cache.put(input,result);
        }
        return result;
    }
}

     在該版本中利用HashMap來保存之前計算的結果，compute方法首先檢查緩存中是否有結果，沒有則計算，把其結果放入緩存並且返回。大家都知道HashMap不是線程安全的，因此要確保多個線程同時訪問的時，Memoizer1采用把對整個方法compute進行同步，這樣的結果導致調用該方法被串行化，如果compute的執行時間比較長，那么后面的線程需要等待更長的時間，結果可能比不用緩存更加糟糕。

     接着我們對該版本進行進一步的優化，把HashMap改為ConcurrentHashMap,因為ConcurrentHashMao是線程安全的，因此在訪問底層的Map的時候不需要進行同步。因此避免了在對compute方法進行同步帶來的串行性。

public class Memoizer2<T,R> implements  Computable<T,R>{

    private  final Map<T,R> cache = new ConcurrentHashMap<>();

    private  final Computable<T,R> computable;

    public Memoizer2(Computable<T, R> computable) {
        this.computable = computable;
    }

    public R compute(T input) throws InterruptedException {
        R result= cache.get(input);
        if(result ==null){
            result = computable.compute(input);
            cache.put(input,result);
        }
        return result;
    }
}

 

      在該版本也存在一些不足，當兩個線程同時調用compute時存在一個漏洞，可能會導致計算相同的值。緩存的目的是避免相同的數據被多次計算。我們知道FutureTask 表示一個計算過程，這個過程可能已經完成，也可能正在進行。如果FutureTask結果可用，調用FutureTask.get()將立即得到結果，否則它會一直阻塞，知道計算結果出來再返回。

public class Memoizer3<T,R> implements  Computable<T,R>{

    private  final Map<T,Future> cache = new ConcurrentHashMap<>();

    private  final Computable<T,R> computable;

    public Memoizer3(Computable<T, R> computable) {
        this.computable = computable;
    }

    public R compute(final T input) throws InterruptedException {
        Future<R> future = cache.get(input);
        if (future==null){
            Callable<R> callable = new Callable<R>() {
                @Override
                public R call() throws Exception {
                    return computable.compute(input);
                }
            };
            FutureTask futureTask = new FutureTask(callable);
            future=futureTask;
            cache.put(input,future);
            futureTask.run();
        }
        try{
            return future.get();
        } catch (ExecutionException e) {
            throw  new RuntimeException(e);
        }
    }
}

      在第三個版本Memoizer3的實現幾乎是完美的，它表現出非常好的並發性，如果結果已經計算出來則直接返回，如果其他線程正在計算該結果，那么新到的線程將一直等待這個結果被計算出來。它只有一個缺陷，即仍然存在兩個線程計算出相同值的漏洞。

但是這個概率將遠遠小於第二個版本。由於compute方法中的if代碼仍然是非原子的“先檢查后執行”操作。因此兩個線程仍然有可能在同一時間內調用compute來計算相同的值。在該版本中存在該問題的原因是，復合操作在底層Map對象上執行，而這個對象無法通過加鎖來確保原子性。那么接着把Map.put()改為Map.putIfAbsent()即可。

public class Memoizer4<T,R> implements  Computable<T,R>{

    private  final ConcurrentMap<T,Future> cache = new ConcurrentHashMap<>();

    private  final Computable<T,R> computable;

    public Memoizer4(Computable<T, R> computable) {
        this.computable = computable;
    }

    public R compute(final T input) throws InterruptedException {
        while (true){
            Future<R> future = cache.get(input);
            if (future==null){
                Callable<R> callable = new Callable<R>() {
                    @Override
                    public R call() throws InterruptedException {
                        return computable.compute(input);
                    }
                };
                FutureTask futureTask = new FutureTask(callable);
                future= cache.putIfAbsent(input, futureTask);//如果原先不存在，返回null
                if(future==null){
                    future=futureTask;
                    futureTask.run();
                }
            }
            try{
                return future.get();
            } catch (CancellationException e) {
                cache.remove(input,future);
            } catch (ExecutionException e) {
                throw new RuntimeException(e);
            }
        }
    }

在該版本中應該完美了解決了原先提出的問題。但是還是存在如下問題：沒有解決緩存預期的問題，沒有解決緩存清理問題。