一头扎进多线程-构建高效且可伸缩的结果缓存

通过多线程的所有组件学习之后，我们要学习到如何把一个类包装成一个多线程安全类，下面通过构造一个——计算缓存类，在构造的过程中一步一步的优化，最终来得到我们想要的计算缓存类。

类提供的功能：类提供一个计算的功能，然后把计算传入的值与结果缓存在一个Map中，当第二次计算时先从缓存里面查看看曾经有没有计算过，有的话就直接返回结果，没有的话就进行计算，存到缓存再返回结果。

菜鸟的做法

如果是我的话，首先我会这么做

定义一个计算的接口，里面提供一个计算的方法，等待实现

public interface Computable<A,V> {//V代表返回结果
V computer(A arg);//A表示参数
}

定义一个具体的计算类，用来实现计算的功能

public class ExpensiveFunction implements Computable<String,BigInteger> {
/* （非 Javadoc）
* @see com.jjt.cache.Computable#computer(java.lang.Object)
*/
@Override
public BigInteger computer(String arg) {
//模拟经过长时间的计算
return new BigInteger(arg);
}
}

最后定义一个主类来实现我们想要的逻辑，这里使用的是组合的方式来进行计算

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

private final Map<A,V> cache = new HashMap<A,V>();//缓存数据结构
private final Computable<A,V> c;//具体计算类

/**
*
*/
public Memosizer(Computable<A, V> c) {
this.c=c;//构造函数传入一个具体的计算类
}
/* （非 Javadoc）
* @see com.jjt.cache.Computable#computer(java.lang.Object)
*/
@Override
public synchronized V computer(A arg) {//实现我们想要的逻辑
V result = cache.get(arg);
if(result==null){
result = c.computer(arg);
cache.put(arg, result);
}
return result;
}

}

解析上面的代码，我们可以看到，由于hashMap是非线程安全的，所以我们只能通过synchronized 加一个隐形锁来对我们的逻辑进行锁定，但是这样导致我们发生并发时，我们会因为计算时间的关系导致线程间进行长时间的等待，降低了吞吐率。那我们接下来看看如何改进。

把线程安全性交给线程安全Map类管理

//  private final Map<A,V> cache = new HashMap<A,V>();
private final Map<A,V> cache = new ConcurrentHashMap<A,V>();

ConcurrentHashMap内部实现机构是分段锁，去除隐式锁换成并发Map有助于我们增加吞吐量，不过这里又存在另外的一个问题。

延时任务交给FutureTask

我们已经知道有一个类能基本实现这个功能：FutureTask。FutureTask表示一个计算的过程。这个过程可能是已经计算完成，也可能是正在进行。如果结果可用，那么 FutureTask.get将立即返回，否则会一直阻塞，直到结果计算出来再将其返回。

所以我们现在把原来的

ConcurrenHashMap<A,V>，更改为ConcurrentHashMap<A,Future<V>>

我们直接把计算的步骤放到FutureTask里面，让他帮我们进行处理，我们直接把FutureTask放到缓存里面，需要的时候再get出来，这样就可以解决了我们第二个点提到的那个技术难题。改进后的Memosize如下：

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

//  private final Map<A,V> cache = new HashMap<A,V>();
private final Map<A,Future<V>> cache = new ConcurrentHashMap<A,Future<V>>();
private final Computable<A,V> c;//具体计算类

/**
*
*/
public Memosizer(Computable<A, V> c) {
this.c=c;
}
/* （非 Javadoc）
* @see com.jjt.cache.Computable#computer(java.lang.Object)
*/
@Override
public  V computer(A arg) throws InterruptedException, ExecutionException {//去除分段锁之后
Future<V> result = cache.get(arg);
if(result==null){
Callable<V> callable = new Callable<V>() {
@Override
public V call() throws Exception {
return c.computer(arg);
}
};
FutureTask<V> f = new FutureTask<V>(callable);
result=f;
cache.put(arg, result);
f.run();//这里将调用c.compute方法，在这里线程被阻塞等没关系，因为futureTask已经进了缓存了
}
return result.get();
}
}

虽然上面的代码看起来好像几乎是完美的，但是不要忘了还存在一个非原子操作

高手最后的进阶