executor框架

　　JDK5的java.util.concurrent包中的执行器将为你管理Thread对象，从而简化了并发编程。Executor在客户端和任务执行之间提供了一个间接层；与客户端直接执行任务不同，这个中介对象执行任务。Executor允许你管理异步任务的执行，而无须显示的管理线程的周期。

　　Eexecutor作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用Runnable来表示任务，Executor的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。

　　在HotSoop VM的线程模型中，java线程被一对一映射为本地操作系统线程。java线程启动时会创建一个本地操作系统线程，当该java线程终止时，这个操作系统线程也会被回收，操作系统会调度所有线程并将它们分配给可用的CPU。

　　在上层，java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定数量的线程。在底层，操作系统内核将这些线程映射到硬件处理器上。

组成部分

任务

包括被执行任务需要实现的接口：Runnable接口或Callable接口。

任务的执行

包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。

Executor框架有两个关键类实现了ExecutorService接口ThreadPoolExecutor和ScheduledThreadPoolExecutor。

异步计算的结果

包括接口Future和实现Future接口的FutureTask类。

成员构成图

Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。

ExecutorService接口继承了Executor，在其上做了一些shutdown()、submit()的扩展，可以说是真正的线程池接口。

AbstractExecutorService抽象类实现了ExecutorService接口中的大部分方法。

ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。

ScheduledExecutorService接口继承了ExecutorService接口，提供了带“周期执行”功能得ExecutorService。

ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。

Future接口和实现Future接口的FutureTask类，代表异步计算结果。

Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

使用流程

主线程首先要创建实现Runnable或者Callable接口的任务对象。

工具类Executors可以把一个Runnable对象封装为一个Callable对象（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object result））。然后可以把Runnable对象直接交给ExecutorService执行（ExecutorService.execute（Runnablecommand））；或者也可以吧Runnable对象或Callable对象交给ExecutorService执行（ExecutorService.submit（Runnable task））或ExecutorService.submit（Callable<T> task）。

如果执行ExecutorService.submit（...），ExecutorService将返回一个实现Future接口的对象（到目前为止的JDK中，返回的是FutureTask对象）。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。

最后，主线程可以执行Future.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel(boolean mayInterruptIfRunning)来取消此任务的执行。

分类

ThreadPoolExecutor通常使用工厂类Executors来创建，通常分为以下3类：

FixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
        　　　　　　　　　　　　　　　　0L, TimeUnit.MILLISECONDS,
        　　　　　　　　　　　　　　　　new LinkedBlockingQueue<Runnable>(),
        　　　　　　　　　　　　　　　　threadFactory);
}

固定线程数适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景，适用于负载比较重的服务器。

FixedThreadPool的corePoolSize和maximumPoolSize都被设置为创建FixedThreadPool时指定的参数nThreads。当线程池中的线程数大于corePoolSize时，keepAliveTime为多余的空闲线程等待新任务的最长时间，超过这个时间后多余的线程将被终止。这里吧keepAliveTime设置为0L，意味着多余的空闲线程会被立即终止。

FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列（队列容量为Integer.MAX_VALUE）。使用无界队列作为工作队列会对线程带来如下影响：

1. 当线程池中的数量达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数量不会超过corePoolSize。
2. 由于1，使用无界队列时maximumPoolSize将是一个无效参数。
3. 由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
4. 由于使用无界队列，运行中的FixedThreadPool（未执行方法shutdown()或shutdownNow()）不会拒绝任务（不会调用RejectedExecutionHandler.rejectedExecution方法）。

SingleThreadExecutor

创建使用单个线程的SingleThreadExecutor的API，适用于需要保证顺序地执行各个人物，并且在任意时间点，不会有多个线程是活动的应用场景。

这对于你希望在另一个线程中连续运行的人物事物（长期存活的任务）来说是很有用的。例如监听进入的套接字连接任务，它对于希望在线程中运行的短任务也同样方便，例如更新本地或远程日志的小任务或者是事件分发线程。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

有无参数的方法，corePoolSize和maximumPoolSize被设置为1，其他参数与FixedThreadPool相同。

CachedThreadPool

创建一个会根据需要创建新线程的CachedThreadPool的API。大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器。

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
}

有无参数方法，corePoolSize被设置为0，即corePool为空，maximumPoolSize被设置为Integer.MAX_VALUE，即maximumPool是无界的，这里吧keepAliveTime设置为60L，意味着CacheThreadPool中的空闲线程等待现任务的最长时间为60秒，空闲60秒后将会被终止。CachedThreadPool使用SynchronousQueue作为线程池的工作队列，但CachedThreadPool的maximumPool是无界的，这意味着，如果主线程提交任务的速度高于maximumPool中的线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。

WorkStealingPool

public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
}

有无参数方法，利用所有运行的处理器数据来创建一个工作窃取的线程池，使用forkjoin实现。

ScheduledThreadPoolExecutor

包含多个线程，适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程数量的应用场景。

步骤

1. 线程从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.task()）。到期任务是指ScheduledFutureTask的time大于等于当前时间。
2. 线程执行这个ScheduledFutureTask。
3. 线程修改ScheduledFutureTask的time变量为下次将要被执行的时间。
4. 线程把这个修改time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add()）。

提交定时任务的方法

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

向定时任务线程池提交一个延时Runnable任务（仅执行一次）

public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)

向定时任务线程池提交一个延时的Callable任务（仅执行一次）

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

向定时任务线程池提交一个固定时间间隔的任务

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

向定时任务线程池提交一个固定延时间隔执行的任务

scheduleAtFixedRate和scheduleWithFixedDelay区别

固定时间间隔的任务不论每次任务话费多少时间，下次任务开始执行时间是确定的，当然执行任务的时间不能超过执行周期。

固定延时间隔的任务执行完任务以后都会延时一个固定时间。由于操作系统调度以及每次任务执行的语句可能不同，所以每次任务执行所花费的时间不确定，也就导致了每次任务的执行周期存在一定的波动。

ScheduleThreadPoolExecutor相较于Timer的优势

• Timer是基于绝对时间的延时执行或周期执行，当系统时间改变，则任务的执行会受到影响。而ScheduleThreadPoolExecutor中，任务基于相对进行周期或延时操作。
• Timer也可以提交多个TimeTask任务，但是有一个线程来执行所有TimeTask，这样并发性受到影响，而ScheduleThreadPoolExecutor可以设定线程池中线程的数量。
• Timer不会捕捉TimerTask的异常，只是简单的停止，这样势必会影响其他TimeTask的执行，而ScheduleThreadPoolExecutor中，如果一个线程因某些原因停止，线程池可以自动创建新的线程来维护线程池中线程的数量。

scheduleAtFixedRate超时问题

若任务处理时长超出设置的定时频率时长，本次任务执行完才开始下次任务，下次任务已经处于超时状态，马上开始执行。

Callable、Future和FutureTask

Future接口和实现Future接口的FutureTask类用来表示异步计算的结果。

当我们把Runnable接口或Callable接口的实现类提交（submit）给ThreadPoolExecutor或ScheduledThreadPoolExecutor时，ThreadPoolExecutor或ScheduledThreadPoolExecutor会向我们返回一个FutureTask对象。

Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled-ThreadPoolExecutor执行。它们之间的区别是Runnable不会返回结果，而Callable可以返回结果。

除了可以自己创建实现Callable接口的对象外，还可以使用工厂类Executors来把一个Runnable包装成一个Callable。

Executors提供的，把一个Runnable包装成一个Callable的API。

public static Callable<Object> callable(Runnable task)  // 假设返回对象Callable1

Executors提供的，把一个Runnable和一个待返回的结果包装成一个Callable的API。

public static <T> Callable<T> callable(Runnable task, T result)  // 假设返回对象Callable2

当任务成功完成后FutureTask.get()将返回该任务的结果。例如，如果提交的是对象Callable1，FutureTask.get()方法将返回null；如果提交的是对象Callable2，FutureTask.get()方法将返回result对象。

FutureTask除了实现Future接口外，还实现了Runnable接口。因此，FutureTask可以交给Executor执行，也可以由调用线程直接执行（FutureTask.run()）。

当FutureTask处于未启动或已启动状态时，执行FutureTask.get()方法将导致调用线程阻塞；当FutureTask处于已完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或抛出异常。

当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会被执行；当FutureTask处于已启动状态时，执行FutureTask.cancel（true）方法将以中断执行此任务线程的方式来试图停止任务；当FutureTask处于已启动状态时，执行FutureTask.cancel（false）方法将不会对正在执行此任务的线程产生影响（让正在执行的任务运行完成）；当FutureTask处于已完成状态时，执行FutureTask.cancel（…）方法将返回false。

 任务完成与否判断

可以使用isDone()方法来判断任务Future是否已经完成，也可以通过get()方法来获取结果来判断，两者不同点在于前者在任务未完成之时并不会阻塞，而后者在没有完成的时候回阻塞。

class TaskWithResult implements Callable<String> {
    private int id;
    public TaskWithResult(int id) {
        this.id = id;
    }
    public String call() throws InterruptedException {
        Thread.sleep(3000);    // 休眠3秒
        return "result of TaskWithResult " + id;
    }
}

public class CallableDemo {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        ArrayList<Future<String>> results = new ArrayList<Future<String>>();
        for(int i = 0; i < 5; i++)
            results.add(exec.submit(new TaskWithResult(i)));
        int i = 0;
        for(Future<String> fs : results) {
            try {
                System.out.println(fs.isDone());    // 判断是否完成
                System.out.println(i);
                System.out.println(fs.get());
            } catch(InterruptedException e) {
                System.out.println(e);
                return;
            } catch(ExecutionException e) {
                System.out.println(e);
            } finally {
                exec.shutdown();
            }
            i ++;
        }
    }
}

输出：

false
0
result of TaskWithResult 0
true
1
result of TaskWithResult 1
true
2
result of TaskWithResult 2
true
3
result of TaskWithResult 3
true
4
result of TaskWithResult 4

执行开始后输出false和0，并在这里阻塞，待3秒完成后输出后续结果。这里由于get()的线程未完成，则发生了阻塞，而isDone()方法则不会。

CompletionService

CompletionService实际上可以看做是Executor和BlockingQueue的结合体。CompletionService在接收到要执行的任务时，通过类似BlockingQueue的put和take获得任务执行的结果。CompletionService的一个实现是ExecutorCompletionService，ExecutorCompletionService把具体的计算任务交给Executor完成。在实现上，ExecutorCompletionService在构造函数中会创建一个BlockingQueue（使用的基于链表的无界队列LinkedBlockingQueue），该BlockingQueue的作用是保存Executor执行的结果。当计算完成时，调用FutureTask的done方法。当提交一个任务到ExecutorCompletionService时，首先将任务包装成QueueingFuture，它是FutureTask的一个子类，然后改写FutureTask的done方法，之后把Executor执行的计算结果放入BlockingQueue中。

与ExecutorService最主要的区别在于submit的task不一定是按照加入时的顺序完成的。CompletionService对ExecutorService进行了包装，内部维护一个保存Future对象的BlockingQueue。只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。它会从Queue中取出Future对象，如果Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。所以，先完成的必定先被取出。这样就减少了不必要的等待时间。

总结：

使用方法一，自己创建一个集合来保存Future存根并循环调用其返回结果的时候，主线程并不能保证首先获得的是最先完成任务的线程返回值。它只是按加入线程池的顺序返回。因为take方法是阻塞方法，后面的任务完成了，前面的任务却没有完成，主程序就那样等待在那儿，只到前面的完成了，它才知道原来后面的也完成了。