深入JAVA并发编程（十）：线程池(三)

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor是可对任务进行延迟/预定调度的执行器（Executor），此类Executor一般实现了ScheduledExecutorService这个接口。

从继承图中可以看到，ScheduledThreadPoolExecutor继承了ThreadPoolExecutor这个普通线程池，我们知道ThreadPoolExecutor中提交的任务都是实现了Runnable接口，但是ScheduledThreadPoolExecutor比较特殊，由于要满足任务的延迟/周期调度功能，它会对所有的Runnable任务都进行包装，包装成一个RunnableScheduledFuture任务。

RunnableScheduledFuture是Future模式中的一个接口，关于Future模式，我们后面会讲解，这里只要知道RunnableScheduledFuture的作用就是可以异步地执行【延时/周期任务】。

另外，我们知道在ThreadPoolExecutor中，需要指定一个阻塞队列作为任务队列。ScheduledThreadPoolExecutor中也一样，不过特殊的是，ScheduledThreadPoolExecutor中的任务队列是一种特殊的延时队列（DelayQueue）。

我们曾经在并发容器中，分析过DelayQueue，DelayQueue底层基于优先队列（PriorityQueue）实现，是一种“堆”结构，通过该种阻塞队列可以实现任务的延迟到期执行（即每次从队列获取的任务都是最先到期的任务）。

ScheduledThreadPoolExecutor在内部定义了DelayQueue的变种——DelayedWorkQueue，它和DelayQueue类似，只不过要求所有入队元素必须实现RunnableScheduledFuture接口。

ScheduledThreadPoolExecutor源码分析

首先我们来看下它的构造方法

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }


    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }


    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), handler);
    }


    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory,
                                       RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory, handler);
    }

我们发现其构造方法内部实际上调用了其父类ThreadPoolExecutor的构造方法，但是区别是任务队列的选择——DelayedWorkQueue，我们后面会详细介绍它的实现原理。

线程池的调度

ScheduledThreadPoolExecutor的核心调度方法是schedule、scheduleAtFixedRate、scheduleWithFixedDelay。
我们通过schedule方法来看下整个调度流程：

该方法的作用是提交一个延迟执行的任务，任务在提交delay时间后开始执行，任务只会执行一次。

    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                          triggerTime(delay, unit)));
        delayedExecute(t);
        return t;
    }

decorateTask方法会把Runnable任务包装成ScheduledFutureTask，用户可以根据自己的需要覆写该方法：

    protected <V> RunnableScheduledFuture<V> decorateTask(
        Runnable runnable, RunnableScheduledFuture<V> task) {
        return task;
    }

注意：ScheduledFutureTask是RunnableScheduledFuture接口的实现类，任务通过period字段来表示任务类型

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

	    /**
	     * 任务序号, 自增唯一
	     */
        private final long sequenceNumber;

        /**
	     * 首次执行的时间点
	     */
        private long time;

        /**
         * 任务类型
	     * 0: 非周期任务
	     * >0: fixed-rate任务
	     * <0: fixed-delay任务
	     */
        private final long period;

        /** The actual task to be re-enqueued by reExecutePeriodic */
        RunnableScheduledFuture<V> outerTask = this;

        /**
	     * 在堆中的索引
	     */
        int heapIndex;

        /**
         * Creates a one-shot action with given nanoTime-based trigger time.
         */
        ScheduledFutureTask(Runnable r, V result, long ns) {
            super(r, result);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

        /**
         * Creates a periodic action with given nano time and period.
         */
        ScheduledFutureTask(Runnable r, V result, long ns, long period) {
            super(r, result);
            this.time = ns;
            this.period = period;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

        /**
         * Creates a one-shot action with given nanoTime-based trigger time.
         */
        ScheduledFutureTask(Callable<V> callable, long ns) {
            super(callable);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

        public long getDelay(TimeUnit unit) {
            return unit.convert(time - now(), NANOSECONDS);
        }

        public int compareTo(Delayed other) {
            if (other == this) // compare zero if same object
                return 0;
            if (other instanceof ScheduledFutureTask) {
                ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
                long diff = time - x.time;
                if (diff < 0)
                    return -1;
                else if (diff > 0)
                    return 1;
                else if (sequenceNumber < x.sequenceNumber)
                    return -1;
                else
                    return 1;
            }
            long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
            return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
        }

        /**
         * Returns {@code true} if this is a periodic (not a one-shot) action.
         *
         * @return {@code true} if periodic
         */
        public boolean isPeriodic() {
            return period != 0;
        }

        /**
         * Sets the next time to run for a periodic task.
         */
        private void setNextRunTime() {
            long p = period;
            if (p > 0)
                time += p;
            else
                time = triggerTime(-p);
        }

        public boolean cancel(boolean mayInterruptIfRunning) {
            boolean cancelled = super.cancel(mayInterruptIfRunning);
            if (cancelled && removeOnCancel && heapIndex >= 0)
                remove(this);
            return cancelled;
        }

        /**
         * Overrides FutureTask version so as to reset/requeue if periodic.
         */
        public void run() {
            boolean periodic = isPeriodic();
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            else if (!periodic)
                ScheduledFutureTask.super.run();
            else if (ScheduledFutureTask.super.runAndReset()) {
                setNextRunTime();
                reExecutePeriodic(outerTask);
            }
        }
    }

ScheduledThreadPoolExecutor中的任务队列——DelayedWorkQueue，保存的元素就是ScheduledFutureTask。DelayedWorkQueue是一种堆结构，time最小的任务会排在堆顶（表示最早过期），每次出队都是取堆顶元素，这样最快到期的任务就会被先执行。如果两个ScheduledFutureTask的time相同，就比较它们的序号——sequenceNumber，序号小的代表先被提交，所以就会先执行。

schedule的核心是其中的delayedExecute方法：

    private void delayedExecute(RunnableScheduledFuture<?> task) {
    	//线程池已关闭，拒绝该任务
        if (isShutdown())
            reject(task);
        else {
        	// 将任务入队
            super.getQueue().add(task);
            // 如果线程池已关闭且该任务是非周期任务, 则将其从队列移除
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                // 取消任务
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

整个过程如下

(1)首先，任务被提交到线程池后，会判断线程池的状态，如果线程池已关闭会执行拒绝策略。

(2)然后，将任务添加到阻塞队列中。（注意，由于DelayedWorkQueue是无界队列，所以一定会add成功）

(3)然后，会调用ensurePrestart创建一个工作线程，加入到核心线程池或者非核心线程池：

    void ensurePrestart() {
        int wc = workerCountOf(ctl.get());
        if (wc < corePoolSize)
            addWorker(null, true);
        else if (wc == 0)
            addWorker(null, false);
    }

通过ensurePrestart可以看到，如果核心线程池未满，则新建的工作线程会被放到核心线程池中。如果核心线程池已经满了，ScheduledThreadPoolExecutor不会像ThreadPoolExecutor那样再去创建归属于非核心线程池的工作线程，而是直接返回。也就是说，在ScheduledThreadPoolExecutor中，一旦核心线程池满了，就不会再去创建工作线程。

这里思考一点，什么时候会执行else if (wc == 0)创建一个归属于非核心线程池的工作线程？
答案是，当通过setCorePoolSize方法设置核心线程池大小为0时，这里必须要保证任务能够被执行，所以会创建一个工作线程，放到非核心线程池中。

最后，线程池中的工作线程会去任务队列获取任务并执行，当任务被执行完成后，如果该任务是周期任务，则会重置time字段，并重新插入队列中，等待下次执行。这里注意从队列中获取元素的方法：

• 对于核心线程池中的工作线程来说，如果没有超时设置（allowCoreThreadTimeOut == false），则会使用阻塞方法take获取任务（因为没有超时限制，所以会一直等待直到队列中有任务）；如果设置了超时，则会使用poll方法（方法入参需要超时时间），超时还没拿到任务的话，该工作线程就会被回收。

• 对于非工作线程来说，都是调用poll获取队列元素，超时取不到任务就会被回收。

上面我们知道了如何向延迟队列添加元素，接下来我们来看下线程池中的线程如何获取并执行任务。我们知道具体执行任务的都是Worker线程，然后调用任务的run方法执行，这里的任务是ScheduledFutureTask，我们来看下ScheduledFutureTask的run方法

        public void run() {
        	//判断是不是周期任务
            boolean periodic = isPeriodic();
            //在线程池处于正在关闭状态是能否继续执行，默认是false
            if (!canRunInCurrentRunState(periodic))
            	//取消任务
                cancel(false);
            //如果不是周期任务，那么调用父类的run方法执行任务
            else if (!periodic)
                ScheduledFutureTask.super.run();
            //如果是周期任务，那么调用父类的runAndReset方法执行任务
            //调用成功后，设置下次执行的时间，并加入到任务队列
            else if (ScheduledFutureTask.super.runAndReset()) {
                setNextRunTime();
                reExecutePeriodic(outerTask);
            }
        }

在调用run方法的时候，会检测线程池的状态，如果线程池处于正在关闭的状态（比如调用shutdown方法但尚未执行完成），会调用canRunInCurrentRunState方法，这个方法根据ScheduledThreadPoolExecutor的成员变量continueExistingPeriodicTasksAfterShutdown决定是否继续执行：

//参数periodic为是否是周期任务
boolean canRunInCurrentRunState(boolean periodic) {
	return isRunningOrShutdown(periodic ? continueExistingPeriodicTasksAfterShutdown :
                                   executeExistingDelayedTasksAfterShutdown);
}

经过上述判断后，任务的执行就正式开始了：对于一般的定时任务，默认通过调用父类FutureTask的run方法执行任务。对于周期任务，则是调用父类的runAndReset方法执行任务。对于周期任务，每执行一次，就会调用setNextRunTime方法来算出下次执行的时间：

private void setNextRunTime() {
	long p = period;
    if (p > 0)
        time += p;
    else
        time = triggerTime(-p);
}

setNextRunTime方法会根据周期任务的执行策略来算出下次执行的时间，当period为正数时，说明用户调用的是scheduleAtFixedRate提交的周期任务，反之则是调用的scheduleWithFixedDelay提交的任务。前者会严格按照每隔时间period纳秒就执行一次，后者会根据任务实际的完成时间为起点往后推triggerTime纳秒作为下次的执行时间。
设定完时间后，就会调用reExecutePeriodic方法来使任务重新加入到任务队列：

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
	//再次检测线程池状态，并进行上述判断
	if (canRunInCurrentRunState(true)) {
		//重新入队
    	super.getQueue().add(task);
        if (!canRunInCurrentRunState(true) && remove(task))
            task.cancel(false);
        else
        	//确保线程池有工作线程
            ensurePrestart();
    }
}

延时队列

DelayedWorkQueue，该队列和已经介绍过的DelayQueue区别不大，只不过队列元素是RunnableScheduledFuture：

DelayedWorkQueue是一个无界队列，在队列元素满了以后会自动扩容，它并没有像DelayQueue那样，将队列操作委托给PriorityQueue，而是自己重新实现了一遍堆的核心操作——上浮、下沉。我这里不再赘述这些堆操作，读者可以参考PriorityBlockingQueue自行阅读源码。

我们关键来看下入队和出队方法

        public boolean offer(Runnable x) {
            if (x == null)
                throw new NullPointerException();
            //将插入的任务转为RunnableScheduledFuture类型
            RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
            final ReentrantLock lock = this.lock;
            //加锁
            lock.lock();
            try {
                int i = size;
                //如果当前数组容量已满，那么调用grow方法扩容
                if (i >= queue.length)
                    grow();
                size = i + 1;
                //如果数组元素数量为0，那么放入数组首部
                if (i == 0) {
                    queue[0] = e;
                    setIndex(e, 0);
                //否则调用siftUp方法入队
                } else {
                    siftUp(i, e);
                }
                //如果队列头部就是插入的元素（即执行时间最近的任务），那么唤醒一个在available上等待的线程
                if (queue[0] == e) {
                    leader = null;
                    available.signal();
                }
            } finally {
                lock.unlock();
            }
            return true;
        }

private void siftUp(int k, RunnableScheduledFuture<?> key) {
	while (k > 0) {
		//相当于将k/2
    	int parent = (k - 1) >>> 1;
        RunnableScheduledFuture<?> e = queue[parent];
        //比较大小，直到key的执行时间晚于queue[parent]
        if (key.compareTo(e) >= 0)
            break;
        queue[k] = e;
        setIndex(e, k);
        k = parent;
    }
    //向数组插入元素
    queue[k] = key;
    setIndex(key, k);
}

我们来看下出队方法

        public RunnableScheduledFuture<?> take() throws InterruptedException {
            final ReentrantLock lock = this.lock;
            //尝试获得锁，如果线程被Interrupt则方法抛出异常，随即结束
            lock.lockInterruptibly();
            try {
            	//自旋操作，直到获取到元素为止
                for (;;) {
                    RunnableScheduledFuture<?> first = queue[0];
                    //如果队列头部为空，就阻塞当前线程，同时释放锁
                    if (first == null)
                        available.await();
                    else {
                    	//获取队头任务开始执行的时间，单位为纳秒
                        long delay = first.getDelay(NANOSECONDS);
                        //如果小于等于0，说明已经达到执行时间，从队列中弹出这个元素并返回
                        if (delay <= 0)
                            return finishPoll(first);
                        first = null; // don't retain ref while waiting
                        //到这里说明没有任务到达执行时间，这里和dealyQueue的处理一样
                        //如果leader不为null，那么阻塞当前线程
                        if (leader != null)
                            available.await();
                        else {
                        	//否则将当前线程作为leader
                            Thread thisThread = Thread.currentThread();
                            leader = thisThread;
                            try {
                            	//等待delay时间，再次重试
                                available.awaitNanos(delay);
                            } finally {
                                if (leader == thisThread)
                                    leader = null;
                            }
                        }
                    }
                }
            } finally {
            	//如果leader为null并且队列头部不为空，那么唤醒等待的线程
                if (leader == null && queue[0] != null)
                    available.signal();
                lock.unlock();
            }
        }

Future模式

Future模式是Java多线程设计模式中的一种常见模式，它的主要作用就是异步地执行任务，并在需要的时候获取结果。我们知道，同步调用一个方法时，需要等待方法执行完成，调用线程才会继续往下执行，如果是一些比较复杂的任务，需要等待的时间可能就会比较长。

遇到这种情况呢，我们一般是新建线程异步执行该任务，如下：

public void calculate(){
    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            model.calculate();
        }
    });
    t.start();
}

但是，这样有一个问题，就是拿不到计算结果，也不知道任务到底什么时候计算结束。Future模式就是来解决这个问题的。

Future模式，可以让调用方立即返回，然后自己会在后面慢慢处理，此时调用者拿到的仅仅是一个凭证，调用者可以先去处理其它任务，在真正需要用到调用结果的场合，再使用凭证去获取调用结果。这个凭证就是这里的Future。
Future模式可以理解为一种凭证，拿着该凭证在将来的某个时间点可以取到我想要的东西，可见，Future模式的命名是很有深意且很恰当的。

JDK提供了一系列的接口来实现Future模式。

首先是Callable接口，它功能和Runnable类似，但是具有返回值。表示一个具有返回结果的任务

@FunctionalInterface
public interface Callable<V> {

    V call() throws Exception;
}

所以，如果需要返回值的任务类我们需要实现Callable接口。
如下例，我们进行了运算，然后返回一个Double值：

public class ComplexTask implements Callable<Double> {
    @Override
    public Double call() {
        // complex calculating...
        return ThreadLocalRandom.current().nextDouble();
    }
}

J.U.C还提供了Future接口和它的实现类FutureTask，这个就是凭证，用来获取任务结果。

ComplexTask task = new ComplexTask();
Future<Double> future = new FutureTask<Double>(task);

上面的FutureTask就是真实的“凭证”，Future则是该凭证的接口。

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);


    boolean isCancelled();


    boolean isDone();


    V get() throws InterruptedException, ExecutionException;


    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future接口很简单，提供了isCancelled和isDone两个方法监控任务的执行状态，一个cancel方法用于取消任务的执行。两个get方法用于获取任务的执行结果，如果任务未执行完成，除非设置超时，否则调用线程将会阻塞。

此外，为了能够被线程或线程池执行任务，凭证还需要实现Runnable接口，所以J.U.C还提供了一个RunnableFuture接口，其实就是组合了Runnable和Future接口：

public interface RunnableFuture<V> extends Runnable, Future<V> {

    void run();
}

上面提到的FutureTask，其实就是实现了RunnableFuture接口的“凭证”：

从FutureTask的构造函数可以知道，FutureTask既可以包装Callable任务，也可以包装Runnable任务，但最终都是将Runnable转换成Callable任务。

最终，我们可以以下面这种方式使用Future模式，异步地获取任务的执行结果。

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ComplexTask task = new ComplexTask();
    Future<Double> future = new FutureTask<Double>(task);
    
    // time passed...
    
    Double result = future.get();
}

通过上面的分析，可以看到，整个Future模式其实就三个核心组件：

• 任务类，即示例中的ComplexTask
• Future接口（调用方使用该凭证获取真实任务/数据的结果），即Future接口
• Future实现类（用于对真实任务/数据进行包装），即FutureTask实现类