正确使用缓存以获得更好的性能表现

翻译自javacreed

通过正确使用缓存，可以避免让我们重复的去计算大量数据或者反复的去读取硬件设备。缓存节约了时间，但是消耗了内存。通过使用缓存，我们可以把结果保存在内存中，在下次使用的时候可以直接获得该结果。

在这篇文章中，我们将学习到如何实现一个线程安全的缓存策略。

一般的缓存策略是:

if value in cache
  return value from cache
else 
  compute value
  set value to cache
  return value

我们可以写一个例子来缓存斐波那契数列的结果

public class TestCache{
  private Map<Integer,Integer> mMap = new HashMap();
  public TestCache(){
    //放入斐波那契数列最开始的两项
    mMap.put(0,1);
    mMap.put(1,1);
  }
  public int getNum(int index){
    if(mMap.contains(index)){
      return mMap.get(index);
    }
    int value = getNum(index-1)+getNum(index-2)
    mMap.put(index,value);
    return value;
  }
}

这样我们就把斐波那契数列的每一项都给缓存起来的。
但是这个例子有一个问题，那就是HashMap不是线程安全的。线程不安全的缓存可能在多线程的情况下导致某一个数据被计算两次，这样就违背了我们使用缓存的初衷。
该列子还有一个缺点是设计不良好，缓存类和计算过程耦合性太高，缓存类既要负责缓存，又要负责计算新的数值，不利于扩展。
我们可以使用ConcurrentMap，Callable和Future来更好的重构该类。

1. ConcurrentMap的putIfAbsent方法可以以线程安全的方式添加一个value到Map中，可以在多线程环境下使用。

2. Future的get方法可以以线程安全的方式得到一个值。当在线程A中调用该方法时，如果线程B正在产生这个值，那么线程A将会挂起，通过使用Future可以避免一个值被重复计算两次的问题。

3. 缓存代码被封装在一个Callable中，我们可以在该Callable中缓存任何东西。当我们想要使用另一张算法进行缓存的时候，只需要重写一个Callable就可以。

下面开始来改造这个缓存算法：

public class GenericCache<K,V>{
  //线程安全的map
  private final ConcurrentMap<K,Future<V>> mMap
    = new ConcurrentHashMap();

  //注意这里的参数是Callable，因为可以由Callable构造Future
  private Future<V> createFutureIfAbsent(final K key, final Callable(V) callable){
    Future<V> future= mMap.get(key);
    if(future= null){
      //FutureTask既是Future，也是Runnable，也就是说它既可以执行计算，也可以获得计算结果
      final FutureTask<V> task = new FutureTask<V>(callable);
      //putIfAbsent方法返回该key对应的上一个value
      future = mMap.putIfAbsent(key, task);
      //如果返回的上一个value值为空，说明是第一次添加，需要运行该FutureTask。
      // 为了避免多次计算，我们一定要在这里进行非空判断
      if(future == null){
        future = task;
        task.run();
      }
    }
    return future;
  }

  //用户获得缓存中的值或者得到新值并加入缓存
  public V getValue(final K key, final Callable<V> callable){
    try{
      final Future<V> future = createFutureIfAbsent(key, callable);
      return future.get();
    }catch(Exception e){
      e.printStackTrace();
      //这里要务必要注意，Future的get方法如果抛出了异常，说明计算过程出错了，
       //所以我们要移除该key，允许用户重新添加该key，并重启计算过程
      mMap.remove(key);
    }
  }

  //给外界提供一个把已有值加入Map的接口
  public void setValue(final K key, final V value){
    createFutureIfAbsent(key, new Callable<V>(){
        @Overrid
        public V call(){
          return value;
        }
      });
    }
  }
}

以上算法的精妙之处在于，使用ConcurrentMap来缓存了Future，这样既避免了多线程的安全问题，也避免了重复计算的问题。

createFuturueIfAbsent的写法保证了在多线程下一个key只有一个Future被添加进ConcurrentMap。createFutureIfAbsent写法中一些需要注意的地方已经在注释中写出来了。

getValue允许用户得到新值或者缓存的值，该方法的注意事项也在注释中进行了解释。

接下来还是以斐波那契数列为例，展示一下新算法的用法

public   class FibonacciExample{
  //这是我们用于缓存的算法，可以看出我们把缓存算法的实现和缓存算法的使用分开了，良好的设计模式
  private GenericCache mCache = new GenericCache();
  public FibonacciExample(){
    //初始化数列的前两项
    mCache.setValue(0,1);
    mCache.setValue(1,1);
  }

  public int getNumber(final int index){
    //使用我们的算法去得到值
    return mCache.getValue(index, new Callable<Integer>(){
      @Override
      public Integer call(){
        return getNumber(index - 1)+getNumber(index - 2);
      }
    });
  }
}