Executor执行框架源代码分析（四）——ScheduledThreadPoolExecutor

    在前面一篇Executor执行框架源代码分析（三）中，已经详细介绍了ThreadPoolExecutor的实现方式。ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类，其扩展了ThreadPoolExecutor的功能，扩展的功能主要是用来执行周期性任务的。ScheduledThreadPoolExecutor的任务分为三类：

       1、单一延时任务。设定一个时间，10s。任务将会在提交10秒钟后运行。

       2、固定周期任务。提交一个任务，设定好周期period时间，如，3秒。任务将会每3秒被调用一次，如果任务的执行时间超过了3秒，那么将会在任务执行完之后立即进行再次调用，不会进行并发执行。

       3、周期延时任务。提交一个任务，设置后固定延时时间，如，3秒。任务将会在第一次任务结束之后，延时3秒钟再次调用任务任务第二次。依次类推，第二次调用结束后，延时3秒钟，进行第三次调用。

先看一个demo，感受一下ScheduledThreadPoolExecutor的使用：

public class TestMain02 {
	
	public static void main(String[] args) throws Exception{
		 ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); //创建一个ScheduleThreadPool
		 
		 //周期延时任务，以固定的延时运行任务。参数分别是:
		 //task对象，第一次调用的延时时间（2秒），后续任务调用的延时时间（3秒），延时时间的单位:秒
		 executor.scheduleWithFixedDelay(new Task(), 2,3, TimeUnit.SECONDS); 
	}
}

public class Task implements Runnable{
	@Override
	public void run() {
		 try {
			 System.out.println(this+" 被线程  "+Thread.currentThread().getName()+"  执行！！,开始时间："+new Date());
			 Thread.sleep(4000);
			 System.out.println(this+" 被线程  "+Thread.currentThread().getName()+"  执行！！,结束时间： "+new Date());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

//执行结果
//com.thread.blog.Task@534f5d93 被线程  pool-1-thread-1  执行！！,开始时间：Mon Mar 12 10:46:48 CST 2018
//com.thread.blog.Task@534f5d93 被线程  pool-1-thread-1  执行！！,结束时间： Mon Mar 12 10:46:52 CST 2018 （第一次调用结束）
//com.thread.blog.Task@534f5d93 被线程  pool-1-thread-1  执行！！,开始时间：Mon Mar 12 10:46:55 CST 2018 (3秒钟之后，第二次调用开始)
//com.thread.blog.Task@534f5d93 被线程  pool-1-thread-1  执行！！,结束时间： Mon Mar 12 10:46:59 CST 2018
//如果不关闭executor执行器，会一直按照上面的形式进行输出

上面调用的是scheduleWithFixedDelay方法，这个方法将会以固定的延时时间执行任务。类似的方法还有：

1、schedule(Runnable command,long delay, TimeUnit unit)，提交后延迟执行，延迟时间：delay;

2、scheduleAtFixedRate(Runnable command, long initialDelay，long delay, TimeUnit unit), 提交后延迟执行，第一次延迟时间：initialDelay。后续任务将会以{initialDelay + delay}，{initialDelay + delay*2}……进行执行。即上文所说的“固定周期任务”。

一、schedule方法的实现

schedule方法源代码如下：

public ScheduledFuture<?> schedule(Runnable command,long delay,TimeUnit unit) {
	if (command == null || unit == null)
		throw new NullPointerException();
	
	//调用decorateTask方法包装command
	RunnableScheduledFuture<?> t = decorateTask(command,new ScheduledFutureTask<Void>(command, null,triggerTime(delay, unit)));
	
	//延迟执行command
	delayedExecute(t);
	return t;
}

在上文中有提到，ScheduledThreadPoolExecutor会将提交的task包装成ScheduleFutureTask，再进行执行。schedule方法做的代码中的decorateTask方法的第二个参数就是一个ScheduleFutureTask对象。下文再详细讨论ScheduleFutureTask。

二、scheduleAtFixedRate方法发的实现

源代码如下：

 public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit) {
	if (command == null || unit == null)
		throw new NullPointerException();
	if (period <= 0)
		throw new IllegalArgumentException();
		
	//创建ScheduleFutureTask
	ScheduledFutureTask<Void> sft = 
		new ScheduledFutureTask<Void>(command,null,triggerTime(initialDelay, unit),unit.toNanos(period));
	
	//装饰ScheduleFutureTask
	RunnableScheduledFuture<Void> t = decorateTask(command, sft);
	sft.outerTask = t;
	
	//延时执行
	delayedExecute(t);
	return t;
}

不做过多的解释，与schedule方法的实现是一样的。

三、scheduleWithFixedDelay方法的实现

源代码如下：

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit) {
	if (command == null || unit == null)
		throw new NullPointerException();
	if (delay <= 0)
		throw new IllegalArgumentException();
		
	//创建ScheduleFutureTask	
	ScheduledFutureTask<Void> sft =
		new ScheduledFutureTask<Void>(command,null,triggerTime(initialDelay, unit),unit.toNanos(-delay));
		
	//装饰ScheduleFutureTask	
	RunnableScheduledFuture<Void> t = decorateTask(command, sft);
	sft.outerTask = t;
	
	//延时执行
	delayedExecute(t);
	return t;
}

不多做解释，又是一样的。

从上面三个方法的实现来看，三个方法的实现都是一样的。都是创建了ScheduleFutureTask，然后调用delayedExecutor方法进行执行。所以整个ScheduleThreadPoolExecutor的实现核心是ScheduleFutureTask 和 delayedExectuor。下文将详细分析ScheduleFutureTask  和  delayedExecutor。

四、delayedExecutor方法的实现

源代码如下：

private void delayedExecute(RunnableScheduledFuture<?> task) {
	if (isShutdown()) //如果ScheduleThreadPoolExecutor已经关闭，则拒绝提交task
		reject(task);
	else {
		super.getQueue().add(task); //将任务加入队列
		
		//第二次判断，判断当前任务是否可以运行
		//如果可以运行，则直接运行
		//反之，则取消任务
		if (isShutdown() &&
			!canRunInCurrentRunState(task.isPeriodic()) &&
			remove(task))
			task.cancel(false); //取消任务
		else
			//启动线程，执行任务
			//这个方法可以保证至少有一个线程在运行，是ThreadPoolExecutor中的方法
			//这里就不多做介绍了
			ensurePrestart(); 
	}
}

上面的源代码说明中，delayedExecute方法在执行任务之前，会先判断当前任务是否可以运行。整个判断过程如下：

1、执行器（ScheduleThreadPoolExecutor）是否已经关闭，因为有多线程修改，所以需要多次判断。

2、当task被放入等待队列的瞬间，再次检查执行器的运行状态，如果执行器已经shutdown，则执行canRunInCurrentRunState方法。canRunInCurrentRunState方法的运行状态如下：

boolean canRunInCurrentRunState(boolean periodic) {  
    //这里根据periodic的值，决定isRunningOrShutdown方法的参数  
    //continueExistingPeriodicTasksAfterShutdown是一个bollean值  
    //表示：执行器已经shutdown，是否应该执行前一刻刚刚加入队列的周期任务  
    //    
    //executeExistingDelayedTasksAfterShutdown是一个boolean值，  
    //表示：执行器已经shutdown，是否应该执行前一刻刚刚加入队列的延时任务  
      
      
    //isRunningOrShutdown返回false,表示不再执行刚加入的task;反之，则执行  
    return isRunningOrShutdown(periodic ? continueExistingPeriodicTasksAfterShutdown :executeExistingDelayedTasksAfterShutdown);  
}  

五、ScheduleFutureTask 类的实现

private class ScheduledFutureTask<V> extends FutureTask<V> implements RunnableScheduledFuture<V> {  
  
    private final long sequenceNumber; //提交序列号，会影响getDelay的返回值。先提交的值小于后提交的值  
    
    private final long period; //如果为0，表示不是周期任务；如果不为0，则是周期任务，任务执行周期就是period的值  
  
    RunnableScheduledFuture<V> outerTask = this; //如果是周期性任务，在每次执行完之后，outerTask会被再次插入队列  
  
    int heapIndex; //等待队列中的索引值，用于在等待队列中快速定位当前对象  
  
    ScheduledFutureTask(Runnable r, V result, long ns) {  
        super(r, result);  
        this.time = ns;  
        this.period = 0; //非周期任务  
        //sequencer是维护在其外层类（ScheduledThreadPoolExecutor）中的一个属性  
        this.sequenceNumber = sequencer.getAndIncrement();   
    }  
  
    ScheduledFutureTask(Runnable r, V result, long ns, long period) {  
        super(r, result);  
        this.time = ns;  
        this.period = period;  
        this.sequenceNumber = sequencer.getAndIncrement();  
    }  
  
    ScheduledFutureTask(Callable<V> callable, long ns) {  
        super(callable);  
        this.time = ns;  
        this.period = 0;  
        this.sequenceNumber = sequencer.getAndIncrement();  
    }  
  
    public boolean isPeriodic() {  
        return period != 0;  
    }  
  
    private void setNextRunTime() {  
        long p = period;  
        if (p > 0)  
            time += p;  
        else  
            time = triggerTime(-p);  
    }  
  
    public void run() {  
        boolean periodic = isPeriodic();  
        if (!canRunInCurrentRunState(periodic)) //判断当前任务是否还可以执行  
            cancel(false);  
        else if (!periodic)//不是周期任务，直接调用run方法  
            ScheduledFutureTask.super.run();  
        else if (ScheduledFutureTask.super.runAndReset()) { //runAndSet方法会直接调用task的run方法，完成周期任务的执行  
            setNextRunTime(); //设置下一次执行的时间  
            reExecutePeriodic(outerTask);//这个方法会再次将当前对象放入等待队列，以备下次执行。  
        }  
    }  
}  

上面的代码注释已经完整的说明了ScheduleFutureTask 的结构，这里就不赘述。

       这里有一个很关键的问题，周期任务是如何触发的，以及是如何保证周期任务按照设定的period执行的呢？

六、周期任务的触发

要解答这个问题，需要将关注点放在【delayedExecute】方法上，在delayedExecute的实现中有两个很重要的步骤：

1、将task加入等待队列；【代码：super.getQueue().add(task);】。

2、调用ensurePrestart方法，启动执行。

关于将task加入队列这个操作主要是让线程去队列中获取task，然后执行。这步操作的具体实现在ThreadPoolExecutor的分析中已经说过，这里不再赘述。我们直接讨论ensurePrestart方法，方法实现如下：

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

这个方法调用了addWork方法，这个方法是ThreadPoolExecutor中的实现。主要是新建一个线程，用新建的线程执行提交的task，如果task是null，则从等待队列中获取任务进行执行。

      如上所述，delayedExecute先将task放入队列，然后在调用addWork，传入null值，从队列中获取task执行。之所以要先放入队列，然后再获取；是因为延时任务并不是马上就需要执行的，延时任务都有一个延时时间。

七、如何保证周期任务按照设定的period执行

       保证task按照设定的周期执行主要是通过Schedulefuturetask中的一个time属性实现的。这time属性会记录task下一次运行的时间，在每次运行完之后都会更新这个时间。然后，task在放入等待队列中，这个等待队列会以task的time属性进行排序，time值越小，排序越靠前。执行时依次取出，这样就达到了周期执行的目的。如这段代码：

 //类：ScheduledFutureTask中的run方法  
 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); //加入队列，以备下一次执行  
    }  
}  
  
private void setNextRunTime() {  
    long p = period; //根据周期设置时间  
    if (p > 0)  
        time += p;  
    else  
        time = triggerTime(-p);  
}  
  
void reExecutePeriodic(RunnableScheduledFuture<?> task) {  
    if (canRunInCurrentRunState(true)) {  
        super.getQueue().add(task); //加入队列  
        if (!canRunInCurrentRunState(true) && remove(task))  
            task.cancel(false);  
        else  
            ensurePrestart(); //又再次回到了ensurePrestart方法  
    }  
}  

八、自定义队列DelayedWorkQueue的实现

       上面提到，执行器会将task放入等待队列，并且按照time值的大小进行排序。这里简要的说明一下这个自定义队列的实现，以便可以进一步的理解这个周期调度的实现方式。

1、DelayedWorkQueue中维护了一个数组，默认长度16。当插入的元素超过16时，自动扩容，每次扩容的长度是50%；

2、对于这个数组的增、删、改、查，采用了一种二叉树的方式进行的。如下图：

九、ScheduleThreadPoolExecutor的扩展

     默认情况下，ScheduleThreadPoolExecutor中运行的是一个futureTask类的实例。如果需要修改其运行类型，实现自定义的调度任务时，可以通过下面的形式进行扩展，而不是直接覆盖原有的FutureTask。

public class CustomScheduledExecutor extends ScheduledThreadPoolExecutor {  
   
    static class CustomTask<V> implements RunnableScheduledFuture<V> { ... }  
   
    protected <V> RunnableScheduledFuture<V> decorateTask(  
                 Runnable r, RunnableScheduledFuture<V> task) {  
        return new CustomTask<V>(r, task); //重写decorateTask方法，实现自定义的调度任务  
    }  
   
    protected <V> RunnableScheduledFuture<V> decorateTask(  
                 Callable<V> c, RunnableScheduledFuture<V> task) {  
        return new CustomTask<V>(c, task);//重写decorateTask方法，实现自定义的调度任务  
    }  
    // ... add constructors, etc.  
}}  

总结

       虽然ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类，但其实现方式有很大的不同，主要体现在两个方面：

1、运行的目标对象不同，虽然Task都实现了Runnable接口，但是ScheduleThreadPoolExecutor会将Task包装成一个ScheduledFutureTask，再进行调度执行。

2、采用的是无界队列，ThreadPoolExecutor可以自己定义队列策略，而ScheduleThreadPoolExecutor则没有这个特权，ScheduleThreadPoolExecutor只能采用无界队列，那也就是说ThreadPoolExecutor中的maxmumPoolSize将不会生效。

3、ScheduleThreadPoolExecutor覆写了所有的executor和submit方法，也就是说ScheduleThreadPoolExecutor几乎已经完全剥离了ThreadPoolSize，继承的ThreadPoolSize仅仅只是充当一个线程池的角色，已经没有了执行功能。

4、不能设置allowCoreThreadTimeOut属性值为true，这回导致task没有现成去执行