线程池之ScheduledThreadPoolExecutor线程池源码分析笔记

1.ScheduledThreadPoolExecutor 整体结构剖析。

1.1类图介绍

 

根据上面类图图可以看到Executor其实是一个工具类,里面提供了好多静态方法,根据用户选择返回不同的线程池实例。可以看到ScheduledThreadPoolExecutor 继承了 ThreadPoolExecutor 并实现 ScheduledExecutorService接口。线程池队列是 DelayedWorkQueue,和 DelayedQueue 类似是一个延迟队列。

ScheduledFutureTask 是具有返回值的任务,继承自 FutureTask,FutureTask 内部有个变量 state 用来表示任务的状态,一开始状态为 NEW,所有状态为:

    private static final int NEW          = 0;//初始状态
    private static final int COMPLETING   = 1;//执行中状态
    private static final int NORMAL       = 2;//正常运行结束状态
    private static final int EXCEPTIONAL  = 3;//运行中异常
    private static final int CANCELLED    = 4;//任务被取消
    private static final int INTERRUPTING = 5;//任务正在被中断
    private static final int INTERRUPTED  = 6;//任务已经被中断

FutureTask可能的任务状态转换路径如下所示:

    NEW -> COMPLETING -> NORMAL //初始状态->执行中->正常结束
    NEW -> COMPLETING -> EXCEPTIONAL//初始状态->执行中->执行异常
    NEW -> CANCELLED//初始状态->任务取消
    NEW -> INTERRUPTING -> INTERRUPTED//初始状态->被中断中->被中断

其实ScheduledFutureTask 内部还有个变量 period 用来表示任务的类型,其任务类型如下:

  • period=0,说明当前任务是一次性的,执行完毕后就退出了。

  • period 为负数,说明当前任务为 fixed-delay 任务,是定时可重复执行任务。

  • period 为整数,说明当前任务为 fixed-rate 任务,是定时可重复执行任务。

 

接下来我们可以看到ScheduledThreadPoolExecutor 的造函数如下

    //使用改造后的Delayqueue.
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        //调用父类ThreadPoolExecutor的构造函数
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue());
    }
     public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

根据上面代码可以看到线程池队列是 DelayedWorkQueue

 

2、原理分析

我们主要看三个重要的函数,如下所示:

schedule(Runnable command, long delay,TimeUnit unit)

scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)

scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)

 

2.1、schedule(Runnable command, long delay,TimeUnit unit)方法

该方法作用是提交一个延迟执行的任务,任务从提交时间算起延迟 unit 单位的 delay 时间后开始执行,提交的任务不是周期性任务,任务只会执行一次,代码如下:

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit) {
    //(1)参数校验
    if (command == null || unit == null)
        throw new NullPointerException();

    //(2)任务转换
    RunnableScheduledFuture<?> t = decorateTask(command,
        new ScheduledFutureTask<Void>(command, null,
                                      triggerTime(delay, unit)));
    //(3)添加任务到延迟队列
    delayedExecute(t);
    return t;
}

可以看到上面代码所示,代码(1)参数校验,如果 command 或者 unit 为 null,抛出 NPE 异常。

代码(2)装饰任务,把提交的 command 任务转换为 ScheduledFutureTaskScheduledFutureTask 是具体放入到延迟队列里面的东西,由于是延迟任务,所以 ScheduledFutureTask 实现了 long getDelay(TimeUnit unit) 和 int compareTo(Delayed other) 方法,triggerTime 方法转换延迟时间为绝对时间,也就是把当前时间的纳秒数加上延迟的纳秒数后的 long 型值。

接下来我们需要看 ScheduledFutureTask的构造函数,如下所示:

ScheduledFutureTask(Runnable r, V result, long ns) {
  //调用父类FutureTask的构造函数
  super(r, result);
  this.time = ns;
  this.period = 0;//period为0,说明为一次性任务
  this.sequenceNumber = sequencer.getAndIncrement();
}

根据构造函数可以看到内部首先调用了父类 FutureTask 的构造函数,父类 FutureTask 的构造函数代码如下:

//通过适配器把runnable转换为callable
public FutureTask(Runnable runnable, V result) {
   this.callable = Executors.callable(runnable, result);
   this.state = NEW;       //设置当前任务状态为NEW
}

根据上面代码可以看到FutureTask 中任务又被转换为了 Callable 类型后,保存到了变量 this.callable 里面,并设置 FutureTask 的任务状态为 NEW。

然后 ScheduledFutureTask 构造函数内部设置 time 为上面说的绝对时间,需要注意这里 period 的值为 0,这说明当前任务为一次性任务,不是定时反复执行任务。

其中 long getDelay(TimeUnit unit) 方法代码如下,用来获取当前任务还有多少时间就过期了,代码如下所示:

//元素过期算法,装饰后时间-当前时间,就是即将过期剩余时间
public long getDelay(TimeUnit unit) {
  return unit.convert(time - now(), NANOSECONDS);
}

 

接下来接着看compareTo(Delayed other) 方法,代码如下:

public int compareTo(Delayed other) {
    if (other == this) // compare zero ONLY 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 d = (getDelay(TimeUnit.NANOSECONDS) -
              other.getDelay(TimeUnit.NANOSECONDS));
    return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
}

根据上面代码的执行逻辑,可以看到compareTo 作用是加入元素到延迟队列后,内部建立或者调整堆时候会使用该元素的 compareTo 方法与队列里面其他元素进行比较,让最快要过期的元素放到队首。所以无论什么时候向队列里面添加元素,队首的的元素都是最即将过期的元素。

 

接下来接着看代码(3)添加任务到延迟队列,delayedExecute 的代码如下:

private void delayedExecute(RunnableScheduledFuture<?> task) {

    //(4)如果线程池关闭了,则执行线程池拒绝策略
    if (isShutdown())
        reject(task);
    else {
        //(5)添加任务到延迟队列
        super.getQueue().add(task);

        //(6)再次检查线程池状态
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
            //(7)确保至少一个线程在处理任务
            ensurePrestart();
    }
}

可以看到代码(4)首先判断当前线程池是否已经关闭了,如果已经关闭则执行线程池的拒绝策略(如果不知道线程池的拒绝策略可以看前一篇线程池的介绍。)

否者执行代码(5)添加任务到延迟队列。添加完毕后还要重新检查线程池是否被关闭了,如果已经关闭则从延迟队列里面删除刚才添加的任务,但是有可能线程池线程已经从任务队列里面移除了该任务,也就是该任务已经在执行了,所以还需要调用任务的 cancle 方法取消任务。

如果代码(6)判断结果为 false,则会执行代码(7)确保至少有一个线程在处理任务,即使核心线程数 corePoolSize 被设置为 0.

ensurePrestart 代码如下:

void ensurePrestart() {
    int wc = workerCountOf(ctl.get());
    //增加核心线程数
    if (wc < corePoolSize)
        addWorker(null, true);
    //如果初始化corePoolSize==0,则也添加一个线程。
    else if (wc == 0)
        addWorker(null, false);
    }
}

如上代码首先首先获取线程池中线程个数,如果线程个数小于核心线程数则新增一个线程,否者如果当前线程数为 0 则新增一个线程。

通过上面代码我们分析了如何添加任务到延迟队列,下面我们看线程池里面的线程如何获取并执行任务的,从前面讲解的 ThreadPoolExecutor 我们知道具体执行任务的线程是 Worker 线程,Worker 线程里面调用具体任务的 run 方法进行执行,由于这里任务是 ScheduledFutureTask,所以我们下面看看 ScheduledFutureTask 的 run 方法。代码如下:

public void run() {

    //(8)是否只执行一次
    boolean periodic = isPeriodic();

    //(9)取消任务
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    //(10)只执行一次,调用schdule时候
    else if (!periodic)
        ScheduledFutureTask.super.run();

    //(11)定时执行
    else if (ScheduledFutureTask.super.runAndReset()) {
        //(11.1)设置time=time+period
        setNextRunTime();

        //(11.2)重新加入该任务到delay队列
        reExecutePeriodic(outerTask);
    }
}   

可以看到代码(8)isPeriodic 的作用是判断当前任务是一次性任务还是可重复执行的任务,isPeriodic 的代码如下:

public boolean isPeriodic() {
     return period != 0;
}

可知内部是通过 period 的值来判断,由于转换任务创建 ScheduledFutureTask 时候传递的 period 为 0 ,所以这里 isPeriodic 返回 false。

代码(9)判断当前任务是否应该被取消,canRunInCurrentRunState 的代码如下:

boolean canRunInCurrentRunState(boolean periodic) {
        return isRunningOrShutdown(periodic ?
                                   continueExistingPeriodicTasksAfterShutdown :
                                   executeExistingDelayedTasksAfterShutdown);
}

这里传递的 periodic 为 false,所以 isRunningOrShutdown 的参数为 executeExistingDelayedTasksAfterShutdownexecuteExistingDelayedTasksAfterShutdown 默认是 true 标示当其它线程调用了 shutdown 命令关闭了线程池后,当前任务还是要执行,否者如果为 false,标示当前任务要被取消。

由于 periodic 为 false,所以执行代码(10)调用父类 FutureTask 的 run 方法具体执行任务,FutureTask 的 run 方法代码如下:

public void run() {
        //(12)
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;

        //(13)
        try {

            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    //(13.1)
                    setException(ex);
                }
                //(13.2)
                if (ran)
                    set(result);
            }
        } finally {
            ...省略        
        }
    }

 

可以看到代码(12)如果任务状态不是 NEW 则直接返回,或者如果当前任务状态为NEW但是使用 CAS 设置当然任务的持有者为当前线程失败则直接返回。代码(13)具体调用 callable 的 call 方法执行任务,这里在调用前又判断了任务的状态是否为 NEW 是为了避免在执行代码(12)后其他线程修改了任务的状态(比如取消了该任务)。

如果任务执行成功则执行代码(13.2)修改任务状态,set 方法代码如下:

 protected void set(V v) {
        //如果当前任务状态为NEW,则设置为COMPLETING
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            //设置当前任务终状为NORMAL,也就是任务正常结束
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
 }

如上代码首先 CAS 设置当前任务状态从 NEW 转换到 COMPLETING,这里多个线程调用时候只有一个线程会成功,成功的线程在通过 UNSAFE.putOrderedInt 设置任务的状态为正常结束状态,这里没有用 CAS 是因为同一个任务只可能有一个线程可以运行到这里,这里使用 putOrderedInt 比使用 CAS 函数或者 putLongVolatile 效率要高,并且这里的场景不要求其它线程马上对设置的状态值可见。

这里思考个问题,这里什么时候多个线程会同时执行 CAS 设置任务状态从态从 NEW 到 COMPLETING?其实当同一个 comand 被多次提交到线程池时候就会存在这样的情况,由于同一个任务共享一个状态值 state。

如果任务执行失败,则执行代码(13.1),setException 的代码如下,可见与 set 函数类似,代码如下:

protected void setException(Throwable t) {
        //如果当前任务状态为NEW,则设置为COMPLETING
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;

            //设置当前任务终态为EXCEPTIONAL,也就是任务非正常结束
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); 
finishCompletion(); } }

到这里代码(10)逻辑执行完毕,一次性任务也就执行完毕了,

下面会讲到如果任务是可重复执行的,则不会执行步骤(10)而是执行代码(11)。

 

2.2  scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)方法

当任务执行完毕后,延迟固定间隔时间后再次运行(fixed-delay 任务):其中 initialDelay 说明提交任务后延迟多少时间开始执行任务 command,delay 表示当任务执行完毕后延长多少时间后再次运行 command 任务,unit 是 initialDelay 和 delay 的时间单位。任务会一直重复运行直到任务运行时候抛出了异常或者取消了任务,或者关闭了线程池。scheduleWithFixedDelay 的代码如下:

 public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
        //(14)参数校验
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0)
            throw new IllegalArgumentException();

        //(15)任务转换,注意这里是period=-delay<0
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,                                    triggerTime(initialDelay, unit),
                                          unit.toNanos(-delay));
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        //(16)添加任务到队列
        delayedExecute(t);
        return t;
}

 

如上代码(14)进行参数校验,校验失败则抛出异常,代码(15)转换 command 任务为 ScheduledFutureTask,这里需要注意的是这里传递给 ScheduledFutureTask 的 period 变量的值为 -delay,period < 0 这个说明该任务为可重复执行的任务。然后代码(16)添加任务到延迟队列后返回。

任务添加到延迟队列后线程池线程会从队列里面获取任务,然后调用 ScheduledFutureTask的 run 方法执行,由于这里 period<0 所以 isPeriodic 返回 true,所以执行代码(11),runAndReset 的代码如下:

protected boolean runAndReset() {
        //(17)
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return false;

        //(18)
        boolean ran = false;
        int s = state;
        try {
            Callable<V> c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } finally {

          ...        
    }
        return ran && s == NEW;//(19)
}

该代码和 FutureTask 的 run 类似,只是任务正常执行完毕后不会设置任务的状态,这样做是为了让任务成为可重复执行的任务,这里多了代码(19)如果当前任务正常执行完毕并且任务状态为 NEW 则返回 true 否者返回 false。

如果返回了 true 则执行代码(11.1)setNextRunTime 方法设置该任务下一次的执行时间,setNextRunTime 的代码如下:

private void setNextRunTime() {
            long p = period;
            if (p > 0)//fixed-rate类型任务
                time += p;
            else//fixed-delay类型任务
                time = triggerTime(-p);
 }

 

如上代码这里 p < 0 说明当前任务为 fixed-delay 类型任务,然后设置 time 为当前时间加上 -p 的时间,也就是延迟 -p 时间后在次执行。

总结:本节介绍的 fixed-delay 类型的任务的执行实现原理如下,当添加一个任务到延迟队列后,等 initialDelay 时间后,任务就会过期,过期的任务就会被从队列移除,并执行,执行完毕后,会重新设置任务的延迟时间,然后在把任务放入延迟队列实现的,依次往复。需要注意的是如果一个任务在执行某一个次时候抛出了异常,那么这个任务就结束了,但是不影响其它任务的执行。

 

2.3、scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)方法

相对起始时间点固定频率调用指定的任务(fixed-rate 任务):当提交任务到线程池后延迟 initialDelay 个时间单位为 unit 的时间后开始执行任务 comand ,然后 initialDelay + period 时间点再次执行,然后在 initialDelay + 2 * period 时间点再次执行,依次往复,直到抛出异常或者调用了任务的 cancel 方法取消了任务在结束或者关闭了线程池。

scheduleAtFixedRate 的原理与 scheduleWithFixedDelay 类似,下面我们讲下不同点,首先调用 scheduleAtFixedRate 时候代码如下:

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                              long initialDelay,
                                              long period,
                                              TimeUnit unit) {
    ...
    //装饰任务类,注意period=period>0,不是负的
    ScheduledFutureTask<Void> sft =
        new ScheduledFutureTask<Void>(command,
                                      null,
                                      triggerTime(initialDelay, unit),
                                      unit.toNanos(period));
    ...
     return t;
}

如上代码 fixed-rate 类型的任务在转换 command 任务为 ScheduledFutureTask 的时候设置的 period=period 不在是 -period

所以当前任务执行完毕后,调用 setNextRunTime 设置任务下次执行的时间时候执行的是 time += p 而不在是 time = triggerTime(-p);

总结:相对于 fixed-delay 任务来说,fixed-rate 方式执行规则为时间为 initdelday + n*period; 时候启动任务,但是如果当前任务还没有执行完,下一次要执行任务的时间到了,不会并发执行,下次要执行的任务会延迟执行,要等到当前任务执行完毕后在执行一个任务。

 

3、总结

 ScheduledThreadPoolExecutor 的实现原理,其内部使用的 DelayQueue来存放具体任务,其中任务分为三种,其中一次性执行任务执行完毕就结束了,fixed-delay任务保证同一个任务多次执行之间间隔固定时间,fixed-rate 任务保证任务执行按照固定的频率执行,其中任务类型使用 period 的值来区分。

 

posted @ 2019-06-16 12:18 妮蔻 阅读(...) 评论(...) 编辑 收藏