FutureTask一个可取消的异步计算，FutureTask 实现了Future的基本方法，提空 start cancel 操作，可以查询计算是否已经完成，并且可以获取计算的结果。结果只可以在计算完成之后获取，get方法会阻塞当计算没有完成的时候，一旦计算已经完成，那么计算就不能再次启动或是取消。

一个FutureTask 可以用来包装一个 Callable(一个有返回值的runnable) 或是一个runnable对象。因为FurtureTask实现了Runnable方法，所以一个 FutureTask可以提交(submit)给一个Excutor执行(excution).

       FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。

请看下面代码：

  1. public class Memoizer2<A, V> implements Computable<A, V> {
  2. 	private final Map<A, V> cache = new ConcurrentHashMap<A, V>();
  3. 	private final Computable<A, V> c;
  4.  
  5. 	public Memoizer2(Computable<A, V> c) {
  6. 		this.c = c;
  7. 	}
  8.  
  9. 	public V compute(A arg) throws InterruptedException {
  10. 		V result = cache.get(arg);
  11. 		if (result == null) {
  12. 			/*
  13. 			 * 如果a线程进来，判断为空，开始compute，因为compute的时间比较长，而且put操作是在compute后面
  14. 			 * 所以其它线程不能及时得得到信息，所以这时b、c线程因为result为空而走进来（注意，abc三线程的arg是
  15. 			 * 一样的），于是乎b、c线程也执行compute方法，这样就会造成大量的线程执行重复的操作而导致效率极低
  16. 			 */
  17. 			result = c.compute(arg);
  18. 			cache.put(arg, result);
  19. 		}
  20. 		return result;
  21. 	}
  22. }

      针对上面的情况，我们可能会想，如果我们并不需要一定等到运算结果出来之后执行put，因为此时肯定有很多线程都因为result为null而执行重复的compute，所以我们想先快速定义一个对象并put，以该对象是否为null决定当前的arg是否运算过，这样就可以减少线程执行重复运算的概率，于是FutureTask类为此而来！

      

  1. public class Memoizer<A, V> implements Computable<A, V> {
  2. 	private final ConcurrentMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
  3. 	private final Computable<A, V> c;
  4.  
  5. 	public Memoizer(Computable<A, V> c) {
  6. 		this.c = c;
  7. 	}
  8.  
  9. 	public V compute(final A arg) throws InterruptedException {
  10. 		while (true) {
  11. 			Future<V> f = cache.get(arg);
  12. 			if (f == null) {
  13. 				/*
  14. 				 * 我们摒弃了之前通过判断运算后的值是否为空来决定是否要执行运算，而是判断future是否为null
  15. 				 * 为何？我们在判断f为null后到put操作之间，执行的动作仅仅只是new了俩对象，new俩对象的时间
  16. 				 * 肯定比执行compute短。
  17. 				 * 过程：a线程进来，判断f为null，new了callable和FutureTask，这时a线程立马将future加进map
  18. 				 * ， 因为这段代码的速度很快，以至于b、c线程判断f不为null，直接执行future.get()，但是此时future
  19. 				 * 不一定运算完，所以b、c得等一会，知道a运算完后获取结果，这样我们的b、c线程就不用花时间去
  20. 				 * 执行重复的操作了，直接使用a线程的结果即可！！
  21. 				 */
  22. 				Callable<V> eval = new Callable<V>() {
  23. 					public V call() throws InterruptedException {
  24. 						return c.compute(arg);
  25. 					}
  26. 				};
  27. 				FutureTask<V> ft = new FutureTask<V>(eval);
  28. 				/*
  29. 				 * 注意,这里我们执行的不是普通的put操作，而是"没有则添加"的复合操作，不过这个方法已经提供了原子性
  30. 				 * 这样我们的程序就更安全了！！
  31. 				 */
  32. 				f = cache.putIfAbsent(arg, ft);
  33. 				if (f == null) {
  34. 					f = ft;
  35. 					ft.run();
  36. 				}
  37. 			}
  38. 			try {
  39. 				return f.get();
  40. 			} catch (CancellationException e) {
  41. 				cache.remove(arg, f);
  42. 			} catch (ExecutionException e) {
  43. 				throw LaunderThrowable.launderThrowable(e.getCause());
  44. 			}
  45. 		}
  46. 	}
  47. }

总结：

（1）FutureTask是类似于Runnable的一种存在，可以接受Callable这种带返回结果的接口作构造参数

（2）FutureTask可以脱离主线程而单独开线程去执行其他运算操作

（3）一个FutureTask不论被多少个线程执行run，都只会执行一次，执行一次后就保持在“运算完成”的状态而不会回滚

（4）FutureTask可以保证：从运算线程返回的结果，可以安全的抵达调用运算线程的线程，中间不会出现线程安全问题

 

版权声明：本文为Booker808-java原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Booker808-java/p/9502377.html