专栏首页彤哥读源码死磕 java线程系列之线程池深入解析——定时任务执行流程

死磕 java线程系列之线程池深入解析——定时任务执行流程

注:java源码分析部分如无特殊说明均基于 java8 版本。

注:本文基于ScheduledThreadPoolExecutor定时线程池类。

简介

前面我们一起学习了普通任务、未来任务的执行流程,今天我们再来学习一种新的任务——定时任务。

定时任务是我们经常会用到的一种任务,它表示在未来某个时刻执行,或者未来按照某种规则重复执行的任务。

问题

(1)如何保证任务是在未来某个时刻才被执行?

(2)如何保证任务按照某种规则重复执行?

来个栗子

创建一个定时线程池,用它来跑四种不同的定时任务。

public class ThreadPoolTest03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个定时线程池
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(5);

        System.out.println("start: " + System.currentTimeMillis());

        // 执行一个无返回值任务,5秒后执行,只执行一次
        scheduledThreadPoolExecutor.schedule(() -> {
            System.out.println("spring: " + System.currentTimeMillis());
        }, 5, TimeUnit.SECONDS);

        // 执行一个有返回值任务,5秒后执行,只执行一次
        ScheduledFuture<String> future = scheduledThreadPoolExecutor.schedule(() -> {
            System.out.println("inner summer: " + System.currentTimeMillis());
            return "outer summer: ";
        }, 5, TimeUnit.SECONDS);
        // 获取返回值
        System.out.println(future.get() + System.currentTimeMillis());

        // 按固定频率执行一个任务,每2秒执行一次,1秒后执行
        // 任务开始时的2秒后
        scheduledThreadPoolExecutor.scheduleAtFixedRate(() -> {
            System.out.println("autumn: " + System.currentTimeMillis());
            LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
        }, 1, 2, TimeUnit.SECONDS);

        // 按固定延时执行一个任务,每延时2秒执行一次,1秒执行
        // 任务结束时的2秒后,本文由公从号“彤哥读源码”原创
        scheduledThreadPoolExecutor.scheduleWithFixedDelay(() -> {
            System.out.println("winter: " + System.currentTimeMillis());
            LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
        }, 1, 2, TimeUnit.SECONDS);
    }
}

定时任务总体分为四种:

(1)未来执行一次的任务,无返回值;

(2)未来执行一次的任务,有返回值;

(3)未来按固定频率重复执行的任务;

(4)未来按固定延时重复执行的任务;

本文主要以第三种为例进行源码解析。

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();

    // 将普通任务装饰成ScheduledFutureTask
    ScheduledFutureTask<Void> sft =
        new ScheduledFutureTask<Void>(command,
                                      null,
                                      triggerTime(initialDelay, unit),
                                      unit.toNanos(period));
    // 钩子方法,给子类用来替换装饰task,这里认为t==sft
    RunnableScheduledFuture<Void> t = decorateTask(command, sft);
    sft.outerTask = t;
    // 延时执行
    delayedExecute(t);
    return t;
}

可以看到,这里的处理跟未来任务类似,都是装饰成另一个任务,再拿去执行,不同的是这里交给了delayedExecute()方法去执行,这个方法是干嘛的呢?

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();
    }
}
void ensurePrestart() {
    int wc = workerCountOf(ctl.get());
    // 创建工作线程
    // 注意,这里没有传入firstTask参数,因为上面先把任务扔到队列中去了
    // 另外,没用上maxPoolSize参数,所以最大线程数量在定时线程池中实际是没有用的
    if (wc < corePoolSize)
        addWorker(null, true);
    else if (wc == 0)
        addWorker(null, false);
}

到这里就结束了?!

实际上,这里只是控制任务能不能被执行,真正执行任务的地方在任务的run()方法中。

还记得上面的任务被装饰成了ScheduledFutureTask类的实例吗?所以,我们只要看ScheduledFutureTask的run()方法就可以了。

ScheduledFutureTask类的run()方法

定时任务执行的地方。

public void run() {
    // 是否重复执行
    boolean periodic = isPeriodic();
    // 线程池状态判断
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    // 一次性任务,直接调用父类的run()方法,这个父类实际上是FutureTask
    // 这里我们不再讲解,有兴趣的同学看看上一章的内容
    else if (!periodic)
        ScheduledFutureTask.super.run();
    // 重复性任务,先调用父类的runAndReset()方法,这个父类也是FutureTask
    // 本文主要分析下面的部分
    else if (ScheduledFutureTask.super.runAndReset()) {
        // 设置下次执行的时间
        setNextRunTime();
        // 重复执行,本文由公从号“彤哥读源码”原创
        reExecutePeriodic(outerTask);
    }
}

可以看到,对于重复性任务,先调用FutureTask的runAndReset()方法,再设置下次执行的时间,最后再调用reExecutePeriodic()方法。

FutureTask的runAndReset()方法与run()方法类似,只是其任务运行完毕后不会把状态修改为NORMAL,有兴趣的同学点进源码看看。

再来看看reExecutePeriodic()方法。

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
    // 线程池状态检查
    if (canRunInCurrentRunState(true)) {
        // 再次把任务扔到任务队列中
        super.getQueue().add(task);
        // 再次检查线程池状态
        if (!canRunInCurrentRunState(true) && remove(task))
            task.cancel(false);
        else
            // 保证工作线程足够
            ensurePrestart();
    }
}

到这里是不是豁然开朗了,原来定时线程池执行重复任务是在任务执行完毕后,又把任务扔回了任务队列中。

重复性的问题解决了,那么,它是怎么控制任务在某个时刻执行的呢?

OK,这就轮到我们的延时队列登场了。

DelayedWorkQueue内部类

我们知道,线程池执行任务时需要从任务队列中拿任务,而普通的任务队列,如果里面有任务就直接拿出来了,但是延时队列不一样,它里面的任务,如果没有到时间也是拿不出来的,这也是前面分析中一上来就把任务扔进队列且创建Worker没有传入firstTask的原因。

说了这么多,它到底是怎么实现的呢?

其实,延时队列我们在前面都详细分析过,想看完整源码分析的可以看看之前的《死磕 java集合之DelayQueue源码分析》。

延时队列内部是使用“堆”这种数据结构来实现的,有兴趣的同学可以看看之前的《拜托,面试别再问我堆(排序)了!》。

我们这里只拿一个take()方法出来分析。

public RunnableScheduledFuture<?> take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    // 加锁
    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;
                // 如果前面有线程在等待,直接进入等待
                if (leader != null)
                    available.await();
                else {
                    // 当前线程作为leader
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        // 等待上面计算的延时时间,再自动唤醒
                        available.awaitNanos(delay);
                    } finally {
                        // 唤醒后再次获得锁后把leader再置空
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && queue[0] != null)
            // 相当于唤醒下一个等待的任务
            available.signal();
        // 解锁,本文由公从号“彤哥读源码”原创
        lock.unlock();
    }
}

大致的原理是,利用堆的特性获取最快到时间的任务,即堆顶的任务:

(1)如果堆顶的任务到时间了,就让它从队列中了队;

(2)如果堆顶的任务还没到时间,就看它还有多久到时间,利用条件锁等待这段时间,待时间到了后重新走(1)的判断;

这样就解决了可以在指定时间后执行任务。

其它

其实,ScheduledThreadPoolExecutor也是可以使用execute()或者submit()提交任务的,只不过它们会被当成0延时的任务来执行一次。

public void execute(Runnable command) {
    schedule(command, 0, NANOSECONDS);
}
public <T> Future<T> submit(Callable<T> task) {
    return schedule(task, 0, NANOSECONDS);
}

总结

实现定时任务有两个问题要解决,分别是指定未来某个时刻执行任务、重复执行。

(1)指定某个时刻执行任务,是通过延时队列的特性来解决的;

(2)重复执行,是通过在任务执行后再次把任务加入到队列中来解决的。

彩蛋

到这里基本上普通的线程池的源码解析就结束了,这种线程池是比较经典的实现方式,整体上来说,效率相对不是特别高,因为所有的工作线程共用同一个队列,每次从队列中取任务都要加锁解锁操作。

那么,能不能给每个工作线程配备一个任务队列呢,在提交任务的时候就把任务分配给指定的工作线程,这样在取任务的时候就不需要频繁的加锁解锁了。

答案是肯定的,下一章我们一起来看看这种基于“工作窃取”理论的线程池——ForkJoinPool。

本文分享自微信公众号 - 彤哥读源码(gh_63d1b83b9e01),作者:丹卿

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-11-06

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 死磕 java线程系列之自己动手写一个线程池(续)

    上一章我们自己动手写了一个线程池,但是它是不支持带返回值的任务的,那么,我们自己能否实现呢?必须可以,今天我们就一起来实现带返回值任务的线程池。

    彤哥
  • 死磕 java线程系列之线程池深入解析——未来任务执行流程

    前面我们一起学习了线程池中普通任务的执行流程,但其实线程池中还有一种任务,叫作未来任务(future task),使用它您可以获取任务执行的结果,它是怎么实现的...

    彤哥
  • 死磕 java线程系列之线程池深入解析——体系结构

    Java的线程池是块硬骨头,对线程池的源码做深入研究不仅能提高对Java整个并发编程的理解,也能提高自己在面试中的表现,增加被录取的可能性。

    彤哥
  • 任务的提交与异步执行

    异步编程是一种对 CPU 资源更高效的编程方式,也是提高系统吞吐量的一个非常不错的选择。很多人会认为所谓的异步不就是多线程吗?

    Single
  • Java线程(六):线程池

            自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的...

    高爽
  • Linux任务计划crontab

    我们时常会有一些定期定时的任务,如周期性的清理一下/tmp,周期性的去备份一次数据库,周期性的分析日志等等。而且有时候因为某些因素的限制,执行该任务的时间会很尴...

    软测小生
  • Js异步机制的实现

    JavaScript是一门单线程语言,所谓单线程,就是指一次只能完成一件任务,如果有多个任务,就必须排队,前面一个任务完成,再执行后面一个任务,以此类推。这种模...

    WindrunnerMax
  • 如何解释Event Loop面试官才满意?

    想要了解JavaScript引擎,首先我们从它的运行机制Event Loop来说起。

    童欧巴

扫码关注云+社区

领取腾讯云代金券