Java并发之构建高效且可伸缩的结果缓存

背景

构建一个高效且可伸缩的结果缓存，从多个方案中分析优缺点并最终搞一个最佳实践

前置内容说明

public interface Computable <A,V>{
    
    

    V compute(A arg) throws InterruptedException;
}

public class ExpensiveFunction implements Computable<String, BigInteger> {
    
    

    @Override
    public BigInteger compute(String arg) throws InterruptedException {
    
    
        //经过较长时间计算后的操作

        return new BigInteger(arg);
    }
}

目的：将创建一个Computable包装器，帮助记住之前的计算结果，并将缓存过程封装起来。

1、使用HashMap和同步机制来初始化缓存

public class Memoizer1<A,V> implements Computable<A,V> {
    
    

    private final Map<A,V> cache = new HashMap<A,V>();
    private Computable<A,V> mComputable;

    public Memoizer1(Computable<A,V> computable){
    
    
        mComputable=computable;
    }

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

缺点：
hashMap不是线程安全的，所以对整个方法进行了同步；这种方法能确保线程安全性，但是会带来一个明显的可伸缩性问题，每次只有一个线程能够执compute如果有多个线程在排队等待还未计算出的结果，那么compute方法的计算时间可能比没有缓存操作的计算时间更长

2、使用ConcurrentHashMap处理并发

public class Memoizer2<A,V> implements Computable<A,V> {
    
    

    private final Map<A,V> cache = new ConcurrentHashMap<>();
    private Computable<A,V> mComputable;

    public Memoizer2(Computable<A,V> computable){
    
    
        mComputable=computable;
    }

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

缺点：
相比Memoizer1,Memoizer2对compute去掉了方法同步，并且使用ConcurrentHashMap替代了HashMap；不足之处在于当两个线程同时掉用compute时存在一个漏洞，可能会导致计算得到相同的值,这种情况特别时对于单次初始化的对象缓存来说，风险更大其次时某个线程启动了一个开销很大的计算，而其它线程并不知道这个计算正在进行，那么很可能会重复这个计算

3、FutureTask处理单个线程开销大时，其它线程不知道计算正在进行

public class Memoizer3<A, V> implements Computable<A, V> {
    
    

    private final Map<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
    private Computable<A, V> mComputable;

    public Memoizer3(Computable<A, V> computable) {
    
    
        mComputable = computable;
    }

    @Override
    public V compute(final A arg) throws InterruptedException {
    
    
        Future<V> result = cache.get(arg);
        if (result == null) {
    
    
            Callable<V> callable = new Callable<V>() {
    
    
                @Override
                public V call() throws Exception {
    
    

                    return mComputable.compute(arg);
                }
            };
            FutureTask<V> task = new FutureTask<>(callable);
            result = task;
            cache.put(arg, result);
            task.run();
        }
        try {
    
    
            return result.get();
        } catch (ExecutionException e) {
    
    
            e.printStackTrace();
            throw new InterruptedException(e.getMessage());
        }
    }
}

缺点：
当前表现出了非常好的并发性，若结果已经计算出来，那么将立即返回；如果其它线程在计算结果，那么新到的线程将一直等待这个结果被计算出来；仍然有一个缺陷，即仍然存在两个线程计算出相同值的漏洞；是由于compute方法中if代码块仍然时非原子的先检查再执行操作符合操作（若没有则添加）是在底层的Map对象上执行的，而这个对象无法通过加锁来确保原子性

4、Future+ConcurrentMap中的原子方法putIfAbsent

最佳方案

public class Memoizer4<A, V> implements Computable<A, V> {
    
    

    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();
    private final Computable<A, V> mComputable;

    public Memoizer4(Computable<A, V> computable) {
    
    
        mComputable = computable;
    }

    @Override
    public V compute(final A arg) throws InterruptedException {
    
    
        while (true) {
    
    
            Future<V> result = cache.get(arg);
            if (result == null) {
    
    
                Callable<V> callable = new Callable<V>() {
    
    
                    @Override
                    public V call() throws Exception {
    
    
                        return mComputable.compute(arg);
                    }
                };
                FutureTask<V> task = new FutureTask<>(callable);
                result = cache.putIfAbsent(arg, task);
                if (result == null) {
    
    
                    result = task;
                    task.run();
                }
            }
            try {
    
    
                return result.get();
            } catch (CancellationException e) {
    
    
                //当缓存的是Future而不是值时，将导致缓存污染问题，计算失败或者取消，需要将Future移除
                cache.remove(arg, result);
            } catch (ExecutionException exception) {
    
    
                exception.printStackTrace();
            }
        }
    }
}