【多线程_提高篇】 创建高效且可伸缩的结果缓存

本文摘自<Java 并发实践>

看下面的例子：

public interface Computable<A,V>{
	V computer(A args) throws InterruptedException ;
}

public class ExtensiveFunction implements Computable<String, BigInteger> {

	@Override
	public BigInteger computer(String args) throws InterruptedException {
		// TODO Auto-generated method stub
		//在这里要经过很长时间的计算
		return new BigInteger(args);
	}

}

我们输入一个String，得到一个BigInteger，并且将这两个值缓冲到内存里面。

实现方式1.

public class Memoizer<A, V> implements Computable<A, V> {
	
	private final Map<A,V> cache = new HashMap<A,V>();
	private final Computable<A, V> c;
	
	public Memoizer(Computable<A, V> c){
		this.c =c ;
	}
	
	public synchronized V computer(A args) throws InterruptedException {
		// TODO Auto-generated method stub
		V result = cache.get(args);
		if(result==null){
			result = c.computer(args);
			cache.put(args, result);
		}
		return result;
	}

}

OK，我们synchronized加了锁，确保多线程情况下执行无误。但是，问题来了，这样每次只能执行一个线程。别的线程需要阻塞；如何提升呢？

并发工具类：ConcurrentHashMap：

实现方式2.

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 computer(A args) throws InterruptedException {
		// TODO Auto-generated method stub
		V result = cache.get(args);
		if(result==null){
			result = c.computer(args);
			cache.put(args, result);
		}
		return result;
	}
}

看起来问题似乎都解决了。嗯，仔细想想？

当两个线程在同时调用computer时候，会得到一个相同的值。缓冲的作用是为了避免重复计算，而这里却出现了。如何改进呢？

我们希望用某种方法来表达：

线程X正在执行计算f(27),当另一个线程在查找f(27)时，他能够知道最高效的方法是等待，这需要怎么做呢？ futuretask即可。

实现方式3、

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 computer(final A args) throws InterruptedException {
		// TODO Auto-generated method stub
		Future<V> f = cache.get(args);
		if(f==null){
			Callable<V> eval = new Callable<V>() {

				@Override
				public V call() throws Exception {
					// TODO Auto-generated method stub
					return c.computer(args);
				}
				
			};
			FutureTask<V> ft = new FutureTask<V>(eval);
			f = ft;
			cache.put(args,ft);
			ft.run();
		}
		try {
			return f.get();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

}

在想想，是不是这样就完美了呢？
由于compute代码块中的代码不是原子性的。所以，可能仍有可能在同一时间调用computer来计算相同的值。这个错误就因为：复合操作“若没有，则添加”是对底层map进行操作的。从而无法保证原子性。

解决方法：使用concurrentHashMap中的putIfAbsent

实现方式4

<span style="color:#330000;">public class Memoizer4<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 Memoizer4(Computable<A, V> c){
		this.c=c;
	}
	
	@Override
	public V computer(final A args) throws InterruptedException {
		// TODO Auto-generated method stub
		Future<V> f = cache.get(args);
		if(f==null){
			Callable<V> eval = new Callable<V>() {

				@Override
				public V call() throws Exception {
					// TODO Auto-generated method stub
					return c.computer(args);
				}
				
			};
			FutureTask<V> ft = new FutureTask<V>(eval);
			</span><span style="color:#ff0000;">f = cache.putIfAbsent(args, ft);</span><span style="color:#330000;">
			
			ft.run();
		}
		try {
			return f.get();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

}</span>

.