ConcurrentHashMap与FutureTask的使用

问题：许多应用的计算过程会相当久，因而会采用某种形式的缓存，重用之前的计算结果以降低延迟、提高吞吐量。例如因数分解，其计算过程可能会相当长，采用缓存将是一种不错的选择。但是如果计算过程是一个并发的行为，那么需要考虑多线程之间的同步。如何解决该问题？

首先我们定义一个需要计算很久的接口，如下所示，其中A是输入类型，V是输出类型

package cache;

public interface Computable<A, V> {
	V compute(A arg) throws InterruptedException;    // 该计算过程可能需要很长时间
}

方法一：

  实现缓存一个比较简单的方法是采用HashMap来存储，但是由于HashMap不是线程同步的，因而我们在计算的时候需要加锁，以防止多个线程对HashMap进行操作，如下所示：

package cache;

import java.util.HashMap;
import java.util.Map;

public class Memorizer<A, V> implements Computable<A, V> {
	private final Map<A, V> cache = new HashMap<A, V>();
	private final Computable<A, V> c;
		
	public Memorizer(Computable<A, V> c) {
		this.c = c;
	}

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

}

但是这种方法效率很低，因为每次只能有一个线程在进行计算或者取值

方法二：

为了解决方法一的问题，我们可以采用ConcurrentHashMap来存储缓存，它是线程安全的容器，多线程对它进行操作是，不会出现并发错误问题

package cache;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Memorizer<A, V> implements Computable<A, V> {
	private final Map<A, V> cache = new ConcurrentHashMap<A, V>();
	private final Computable<A, V> c;
		
	public Memorizer(Computable<A, V> c) {
		this.c = c;
	}

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

}

但是这种方法也存在一种问题，当2个线程计算相同的参数arg，并且同时执行到

if (result == null)

时，他们都会开始长时间的重复计算同一个数据，这样会导致降低效率

方法三：

为了解决方法二的问题，一种可行的方法是当一个线程正在计算某个值arg时，另一个线程也需要取arg的计算结果，那么就让后者等待前者计算完成，然后再去取出前者的结果。要实现这种方法，可以采用FutureTask来进行计算过程。

package cache;

import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Memorizer<A, V> implements Computable<A, V> {
	private final ConcurrentHashMap<A, FutureTask<V>> cache = new ConcurrentHashMap<A, FutureTask<V>>();
	private final Computable<A, V> c;

	public Memorizer(Computable<A, V> c) {
		this.c = c;
	}

	@Override
	public V compute(final A arg) throws InterruptedException {
		FutureTask<V> f = cache.get(arg);
		if (f == null) {
			Callable<V> cb = new Callable<V>() {
				public V call() throws InterruptedException {
					return c.compute(arg);    // 真正计算的地方
				}
			};
			FutureTask<V> ft = new FutureTask<V>(cb);
			f = cache.putIfAbsent(arg, ft); // 使用putIfAbsent是因为可以判断是否是第一个加入缓存的，第一个加入的返回null，后加入的返回前面已经加入的值
			if (f == null) {	// 表示第一个加入，进行计算，后加入的不计算，等待第一个加入的计算结果
				f = ft;
				ft.run();	// 开始计算
			}
		}

		try {
			return f.get();  // 等待计算结果，如果计算完成，则返回
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		return null;

	}

}

改进：

在方法三中，如果FutureTask计算失败，或者被取消了，我们需要把加入的移除缓存，并且重新计算

package cache;

import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Memorizer<A, V> implements Computable<A, V> {
	private final ConcurrentHashMap<A, FutureTask<V>> cache = new ConcurrentHashMap<A, FutureTask<V>>();
	private final Computable<A, V> c;

	public Memorizer(Computable<A, V> c) {
		this.c = c;
	}

	@Override
	public V compute(final A arg) throws InterruptedException {
		while (true) {
			FutureTask<V> f = cache.get(arg);
			if (f == null) {
				Callable<V> cb = new Callable<V>() {
					public V call() throws InterruptedException {
						return c.compute(arg);    // 真正计算的地方
					}
				};
				FutureTask<V> ft = new FutureTask<V>(cb);
				f = cache.putIfAbsent(arg, ft); // 使用putIfAbsent是因为可以判断是否是第一个加入缓存的，第一个加入的返回null，后加入的返回前面已经加入的值
				if (f == null) { // 表示第一个加入，进行计算，后加入的不计算，等待第一个加入的计算结果
					f = ft;
					ft.run(); // 开始计算
				}
			}

			try {
				return f.get();  // 等待计算结果，如果计算完成，则返回
			} catch (CancellationException e) {
				cache.remove(arg);	// 计算被取消了，移除，并重新计算
			} catch (ExecutionException e) {
				throw (InterruptedException)e.getCause();
			}
		}
	}

}