并发执行框架

FutureTask

单线程执行框架。
获得线程执行的返回值。

Callable包装成FutureTask，传入Thread对象中(继承了Runnable)，start启动线程，然后通过Future接口的get()拿到返回值。

Callable<Object> callable = new Callable<>(){
	@Override
	public Object call() {
		Object obj = new Object();
		// ...
		reutrn obj;
	}
}
FutureTask<Object> future = new FutureTask<>(callable);
Thread thread = new Thread(future);
Object res = future.get();

ForkJoinPool

多线程执行框架。
拆分任务。分治思想，工作密取。

分治：

工作密取指的是：一个线程完成了自己的任务，可以去帮助其他线程完成任务。

	ForkJoinPool pool = new ForkJoinPool();
	// 有返回值的 task
	ForkJoinTask<Object> task = new MyTask<>();
	pool.invoke(task); // 阻塞
	// pool.execute(task); // 异步
	Object res = task.join(); // 阻塞等待任务执行完并返回结果

	ForkJoinPool pool = new ForkJoinPool();
	// 无返回值的 action
	ForkJoinTask<Object> action = new MyAction<>();
	pool.invoke(action); // 阻塞
	// pool.execute(task); // 异步
	action.join();// 阻塞等待任务执行完

ForkJoinTask 提供了两个常用实现类（递归实现）：

	public abstract class RecursiveTask<V> extends ForkJoinTask<V>
	public abstract class RecursiveAction extends ForkJoinTask<Void> // Void 无返回值

所以只需继承他们就好了

	public MyTask<V> extends RecursiveTask<V> {
		@Override
		public V compute() {
			// ... 提交子任务 invoke(new MyTask<>()); ... invokeAll(myTasks);
			// ... 等待子任务完成再返回 res = myTask1.join() + myTask2.join() ... 
			return null;
		}
	}

	public MyAction<V> extends RecursiveAction<V> {
		@Override
		public void compute() {
			// ... 提交子任务 invoke(new MyAction<>()); ... invokeAll(myActions);
			// 等待子任务完成再结束 foreach action.join();
		}
	}