JavaConcurrency--Executor

线程池：
构建一个新的线程是有一定代价的，因为涉及与操作系统的交互。如果程序中创建了大量的声明周期很短的线程，应该使用线程池。
一个线程池中包含了许多准备运行的空闲线程。

线程池的种类：

newCachedThreadPool//必要时创建线程，空闲线程会被保持60秒
neFixiedThreadPool//该池包含固定数量的线程：空闲线程会一直被保留
newSingleThreadExecutor//只有一个线程的“池”，该线程顺序执行每一个提交的任务
newScheduledThreadPool//用于预定执行二构建的固定线程池，替代java.util.Timer
newSingleThreadScheduledExecutor//用于续订执行而构建的单线程“池”

submit方法：

Future<?> submit (Runnable task);
Future<T> submit (Runnable task,T result);//很少用
Future<T> submit (Callable<T> task)

该池会在方便的时候尽早执行提交的任务。调用submit时，会得到一个Future对象，可用来查询该任务的状态。

第一个submit方法 返回一个奇怪样子的Future<?>.可以使用这样一个对象来调用isDone，cancel or isCancelled。但是get方法在完成的时候只是简单返回null

第二个submit提交一个Runnable，并且Future的get方法在完成的时候返回指定的result对象。

第三个版本的Submit提交一个Callable，并且返回的Future对象将在计算结果准备好的时候得到它

关闭方法:

shutdown();
shutdownNow();

当用完一个线程池的时候，调用shutdown。该方法启动该池的关系序列，被关闭的执行器不在接受新的任务，当所有的任务都完成以后，线程池中的线程死亡

另一种方法是调用shutdownNow。该池是取消尚未开始的所有任务并试图中断正在运行的线程。

使用线程池的步骤：

1. 调用Executors类中静态的方法 newCachedThreadPool 或者newFixedThreadPool
2. 调用submit提交 Runnable 或者 Callable对象
3. 如果想要取消一个任务，或者如果提交Callable对象，那就要保存好返回的Future对象
4. 当不在提交任何任务时，调用shutdown

预定执行：
ScheduledExecutorService接口具有预定执行 或者 重复执行任务而设计的方法。 newScheduledThreadPool 和newSingleThredScheduledExecutor方法将返回实现了ScheduledExecutorService接口的对象。

可以预定Runnable 或者Callable在初始延迟之后只运行一次。也可以预定一个Runnable对象周期性地运行。

ScheduledExecutorService newScheduledThreadPool(int threads);//返回一个线程池，它使用给定的线程数来调度任务。
ScheduledExecutorService newSingleThreadScheduledExecutor();//返回一个执行器，它在一个单独线程中调度任务。

ScheduledFuture<V> schedule(Callable<V> task, long time, TimeUnit unit);
//
ScheduledFuture<?> schedule(Runnable task,long time,TimeUnit unit);
//预定再制定的时间之后执行任务
ScheduledFuture<?> scheduleAtFixedRate(Runnable task,long initialDelay,long period,TimeUnit unit);
//预定在初始的延迟结束后，周期性地运行给定的任务，周期长度是period
ScheduledFuture<?> scheduleWithFixedDelay(Runnable task,long initialDelay,long period,TimeUnit unit);
//预定在初始的延迟结束后，周期性地运行给定的任务，在一次调用完成和下次调用开始之间有长度为delay的延迟

控制任务组：
使用Executor更有实际意义的愿意，是控制一组相关任务。例如，可以在执行器中使用shutdownNow方法取消所有的任务。

invokeAny方法提交所有对象到一个Callable对象的集合中，并返回某个已经完成了的任务的结果。但是无法知道返回的究竟是哪个任务的结果，也许是最先完成的那个任务的结果。

invokeAll方法提交所有对象到一Callable对象的集合中，并返回一个Future对象的列表，代表所有任务的解决方案。

List<Callable<T>> tasks=...;
List<Future<T>> results=executor.invokeAll(tasks);
for(Future<T> result: results){
	ProcessFurther(result.get());
}

这个方法的缺点是如果第一个任务恰巧花去了很多时间，则可能不得不进行等待。

总结：

T invokeAny(Collection<Callable<T>> tasks);//
T invokeAny(Collection<Callable<T>> tasks,long timeout,TimeUnit unit);
//执行给定的任务，返回其中一个任务的结果，第二个方法若发生超时，抛出一个TimeoutException 异常

List<Future<T>> invokeAll(Collection<Callable<T>> tasks);//
List<Future<T>> invokeAll(Collection<Callable<T>> tasks,long timeout,TimeUnit unit);
//执行给定的任务，返回所有任务的结果。第二个方法若发生超时，抛出一个TimeoutException异常。

还可以将结果可获得的顺序保存起来更有实际意义。可以用ExexutorCompletionService来进行排列。
提交任务给完成服务（completion service）。该服务管理Future对象的阻塞队列，其中包含已经提交的任务的执行结果（这些结果为可用时）。
举例：

ExecutorCompletionService<T> service =new ExecutorCompletionService<>(executor);
for(Callable<T> task: tasks){
	service.submit(task);
}

for(int i=0;i<tasks.size();i++){
	ProcessFurther(service.take().get());
}

总结：

ExecutorCompletionService(Executor e);
//构架一个执行器完成服务来收集给定执行器的结果
Future<V> submit(Callable<V> task);
Future<V> submit(Runnable task,V result);
//提交一个任务给底层的执行器
Future<V> take();
//移除下一个已完成的结果，如果没有任何已完成的结果可用则阻塞
Future<V> poll();
Future<V> poll(longtime, TimeUnit unit);
//移除下一个已完成的结果，如果没有任何已完成结果则返回null。第二个方法将等待给定的时间。