15-Executor框架

1. 简介

1.1 Executor框架的两级调度模型

       在HotSpot JVM的线程模型中，Java线程被一对一映射为本地操作系统线程。

       Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收。

       在上层，Java多线程程序通常把应用分解为若干任务，然后由用户级的调度器（Executor）将这些任务映射为固定数量的线程；

       在底层，操作系统内核将这些线程映射到硬件处理器上。

1.2 Executor框架的结构与成员

1.2.1 Executor 框架的结构

       Executor框架主要由3大部分组成：

1. 任务。包括被执行任务需要实现的接口：Runnable接口或Callable接口
2. 任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。
3. 异步计算的结果。包括接口Future 和实现Future接口的FutureTask类。

• Executor是一个接口，是Executor框架的基础，它将任务的提交与任务的执行分离开来。
• ThreadPoolExecutor 是线程池的核心实现类，用来执行被提交的任务。
• ScheduleThreadPoolExecutor 是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。
• Future 接口和实现 Future接口的FutureTask类，代表异步计算的结果。
• Runnable 接口和Callable接口的实现类，都可以被 ThreadPoolExecutor 或 ScheduleThreadPoolExecutor执行。

1.2.2 Executor 框架的成员

（1）ThreadPoolExecutor

       ThreadPoolExecutor通常使用工厂类Executors来创建。

       Executors可以创建3种类型的ThreadPoolExecutor：

       SingleThreadExecutor、FixedThreadPool和CachedThreadPool。

       1. SingleThreadExecutor：创建使用单个线程的SingleThreadExecutor 的API：

public static ExecutorService newSingleThreadExecutor()
    
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)    

       适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景。

       2.FixedThreadPool ：创建使用固定线程数的 FixedThreadPool的API。

public static ExecutorService newFixedThreadPool(int nThreads)
    
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)    

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

       3.CachedThreadPool：创建一个会根据需要创建新线程的CachedThreadPool的API。

public static ExecutorService newCachedThreadPool()
    
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)    

       是大小无界的线程池，适用于执行很多的短期异步任务的程序或负载较轻的服务器。

（2）ScheduledThreadPoolExecutor

       1.ScheduleThreadPoolExecutor：包含若干个线程的ScheduledThreadPoolExecutor

       2.SingleThreadScheduleExecutor：只包含一个线程的ScheduledThreadPoolExecutor

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

       SingleThreadScheduleExecutor 适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务地应用场景。

（3）Future 接口

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

（4）Runnable接口和Callable接口

       可以使用工厂类Executors把一个Runnable包装成一个Callable。

public static Callable<Object> callable(Runnable task)

public static <T> Callable<T> callable(Runnable task, T result)

2. ThreadPoolExecutor 详解

       它是线程池的实现类。

public class ThreadPoolExecutor extends AbstractExecutorService {
    
    private volatile int corePoolSize;
    private volatile int maximumPoolSize;
    private final BlockingQueue<Runnable> workQueue;
    private volatile RejectedExecutionHandler handler;
    
    // ......
}

2.1 SingleThreadExecutor 详解

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

       可以看到，SingleThreadExecutor 正是由于参数corePoolSize及maximumPoolSize的值为1，所以该线程池才始终只有一个线程。

       需要注意的是LinkedBlockingQueue并不是真的没有长度限制，其最大长度为2^31-1

2.2 FixedThreadPool 详解

return new ThreadPoolExecutor(nThreads, nThreads,
                              0L, TimeUnit.MILLISECONDS,
                              new LinkedBlockingQueue<Runnable>());

       keepAliveTime设置为0L，意味着多余的空闲线程会被立即终止。

       FixedThreadPool 使用无界队列作为工作队列，有如下影响：

       1）当线程池中的线程数达到 corePoolSize 后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize。

       2）使用无界队列，maxnumPoolSize 无效。

       3）由于 1）和 2），keepAliveSize 无效。

       4）不会拒绝任务。

2.3 CachedThreadPool 详解

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

       SynchronousQueue是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作，反之亦然。

3. ScheduleThreadPoolExecutor 详解

       主要用来在给定的延迟之后运行任务，或者定期执行任务。

3.1 运行机制

       ScheduleThreadPoolExecutor 为了实现周期性的执行任务，对ThreadPoolExecutor 做了如下的修改：

• 使用DelayQueue作为任务队列
• 获取任务的方式不同
• 执行周期任务后，增加了的处理

3.2 实现原理

       ScheduledThreadPoolExecutor 把待调度的任务（ScheduledFutureTask）放到一个DelayQueue中.

private class ScheduledFutureTask<V>
            extends FutureTask<V> implements RunnableScheduledFuture<V> {

       
        // 表示这个任务被添加到 ScheduledThreadPoolExecutor 中的序号
        private final long sequenceNumber;

        // 表示这个任务将要被执行的具体时间
        private long time;

		// 表示任务执行的间隔周期
        private final long period;
        
        // ......
}

       DelayQueue封装了一个 PriorityQueue，这个PriorityQueue 会对队列中的ScheduledFutureTask进行排序。排序是，time 小的排在前面（时间早的任务将被先执行）。如果两个ScheduledFutureTask 的time相同，就比较 sequenceNumber，sequenceNumber 小的排在前面（任务执行时间相同，先提交的任务先执行）。

​
       1）线程1从 DelayQueue中获取已到期的 ScheduledFutureTask(DelayQueue.take() )。到期任务指 ScheduledFutureTask的time大于等于当前时间。

       2）线程1 执行这个ScheduleFutureTask。

       3）线程1修改ScheduledFutureTask的time 变量为下次将要执行的时间。

       4）线程1 把这个修改time之后的ScheduledFutureTask 放回 DelayQueue中。

       获取任务的过程：

public E take() throws InterruptedException {
    // 获取锁
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek();
            if (first == null)
                //说明队列为空调用condition.await()方法，会使得当前线程释放lock然后加入到等待队列中
                available.await();
            else {
                // 如果第一个数据不为空 
                // 获取消息体的延迟时间（getDelay() 会在消息体内重写 自定义添加延迟时间）
                long delay = first.getDelay(NANOSECONDS);
                
                if (delay <= 0)
                    //如果延迟时间 小于等于0 说明已经达到了延迟时间 调用poll方法返回消息体
                    return q.poll();
                
                //如果延迟时间不为空的话 说明还需要等待一段时间 此时重新循环 所以将frist置为空
                first = null; // don't retain ref while waiting
                
                if (leader != null)
                    available.await();
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay);
                    } finally {
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && q.peek() != null)
            // 唤醒睡眠的线程
            available.signal();
        lock.unlock();
    }
}

       1）获取Lock

       2）获取周期任务

              1、如果 PriorityQueue 为空，当前线程到 Condition 中等待；

              2、如果 PriorityQueue 的头元素的time 时间比当前时间早，到Condition中等待到time时间。否则返回任务。

              3、获取 PriorityQueue 的头元素，如果PriorityQueue 不为空，则唤醒在 Condition 中等待的所有线程

       3）释放锁

       添加任务到队列：

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    // 获取锁
    lock.lock();
    try {
        // 向 PriorityQueue 添加任务
        q.offer(e);
        if (q.peek() == e) {
            leader = null;
            // 如果添加的元素是头元素，则唤醒在 Condition 中等待的所有线程
            available.signal();
        }
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

4. FutureTask 详解

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

4.1 简介

       除了实现Future接口外，还实现了Runnable接口。因此FutureTask 可以交给Executore执行，也可以调用线程直接执行（FutureTask.run()）。根据 FutureTask.run()方法被执行的时机，FutureTask 可以由如下3种状态：

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

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

4.2 实现原理

       FutureTask 的实现基于 AbstractQueuedSynchronizer（AQS）。AQS 是一个同步框架，它提供通用机制来原子性管理同步状态、阻塞和唤醒线程，以及被阻塞线程的队列。

       每一个基于 AQS实现的同步器都会包含两种类型的操作：

       1、至少一个acquire操作。这个操作阻塞调用线程，除非直到 AQS的状态运行这个线程继续执行。FutureTask 的 acquire操作为get()/get(long timeout,TimeUnit unit)方法调用。

       2、至少一个 release操作。这个操作改变AQS的状态，改变后的状态可运行一个或多个阻塞线程被解除阻塞。FutureTask 的 release操作包括run()方法和cancel()方法。

       Sync 是 FutureTask 的内部私有类，它继承自AQS。创建FutureTask时会创建内部私有的成员对象Sync，FutureTask 所有的公有方法直接委托给了内部私有的Sync。

       FutureTask.get() 方法会调用 AQS.acquireSharedInterruptibly(int arg)方法，执行过程如下：

              1）调用 AQS.acquireSharedInterruptibly(int arg)方法，这个方法首先会回调在子类Sync中实现的tryAcquireShared()方法来判断 acquire 操作是否可以成功。成功的条件是：state 为执行完成状态RAN或已取消状态CANCELLED，且runner 不为null。

              2）如果成功则 get () 方法立即返回。如果失败，则到线程等待队列中去等待其他线程执行release 操作。

              3）当其他线程执行 release操作（如 FutureTask.run()或FutureTask.cancel(...) 唤醒当前线程后，当前线程再次执行tryAcquireShared()将返回值1，当前线程将离开线程等待队列并唤醒它的后继线程（产生级联唤醒）。

              4）最后返回的计算结果或者抛出异常。

       FutureTask.run()的执行过程如下：

              1）执行在构造函数中指定的任务（Callable.call()）

              2）以原子的方式更新同步状态（调用AQS.compareAndState(int expect,int update)），设置state 为执行完成RAN）。如果这个原子操作成功，就设置代表计算结果的变量result的值为Callable.call()的返回值，然后调用AQS.releaseShared(int arg)。

              3）AQS.releaseShared(int arg)首先会回调在子类Sync中实现的tryReleaseShared(arg)来执行release操作（设置运行任务的线程 runner 为null，然后返回true）；AQS.releaseShared(int arg)，然后唤醒线程等待队列中的第一个线程。

              4）调用 FutureTask.done()

              当执行 Future.get()方法时，如果 FutureTask不是处于执行完成状态RAN或已取消状态CANCELLED，当前执行线程将到AQS的线程等待（如下图的线程A、B、C、D）。当线程执行FutureTask.run()方法或FutureTask.cancel() 方法时，会唤醒线程等待队列的第一个线程（线程E唤醒线程A）

              假设开始时FutureTask处于未启动状态或已启动状态，等待队列中已经有3个线程（A、B和C）在等待。此时，线程D执行get()方法将导致线程D也到等待队列中取等待。

              当线程E执行run()方法时，会唤醒队列中的第一个线程A。线程A唤醒后，首先把自己从等待队列中删除，然后唤醒它的后继线程B，最后线程A从get()方法返回。线程B、C和D重复A线程的处理流程。最终，在队列中等待的所有线程都被级联唤醒并从get()方法返回。