ScheduledThreadPoolExecutor JDK定时任务线程池

最新推荐文章于 2024-02-29 10:07:36 发布

csdn_9527666

最新推荐文章于 2024-02-29 10:07:36 发布

阅读量306

点赞数

分类专栏： JUC

原文链接：https://www.jianshu.com/p/18f4c95aca24

版权

JUC 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

https://www.jianshu.com/p/18f4c95aca24

流程：

1 提交任务的时候，任务被包装成ScheduledFutureTask对象加入延迟队列并启动一个woker线程。

2 用户提交的任务加入延迟队列时，会按照执行时间进行排列，也就是说队列头的任务是需要最早执行的。而woker线程会从延迟队列中获取任务，如果已经到了任务的执行时间，则开始执行。否则阻塞等待剩余延迟时间后再尝试获取任务。

3 任务执行完成以后，如果该任务是一个需要周期性反复执行的任务，则计算好下次执行的时间后会重新加入到延迟队列中。

特性：

1 使用DelayedWorkQueue作为阻塞队列，并没有像ThreadPoolExecutor类一样开放给用户进行自定义设置。该队列是ScheduledThreadPoolExecutor类的核心组件，后面详细介绍。

2 这里没有向用户开放maximumPoolSize的设置，原因是DelayedWorkQueue中的元素在大于初始容量16时，会进行扩容，也就是说队列不会装满，maximumPoolSize参数即使设置了也不会生效。

3 worker线程没有回收时间，原因跟第2点一样，因为不会触发回收操作。所以这里的线程存活时间都设置为0。

继承了 ThreadPoolExecutor 实现了 ScheduledExecutorService 接口

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));
        //然后在调用decorateTask进行包装，该方法是留给用户去扩展的，默认是个空方法
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        //延迟执行
        delayedExecute(t);
        return t;
    }

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
                //这里是增加一个worker线程，避免提交的任务没有worker去执行
                //原因就是该类没有像ThreadPoolExecutor一样，woker满了才放入队列
                ensurePrestart();
        }
    }

线程启动后，由ScheduledThreadPoolExecutor的父类ThreadPoolExecutor接管。

ensurePrestart:

代码块

    void ensurePrestart() {
        int wc = workerCountOf(ctl.get());
        if (wc < corePoolSize)
            // 增加一个线程并启动
            addWorker(null, true);
        else if (wc == 0)
            addWorker(null, false);
    }

addWorker方法会调用新创建线程的 start方法

线程获得cpu时间片后执行线程的run方法调用runworker方法

代码块

    public void run() {
            runWorker(this);
        }

        final void runWorker(Worker w) {

        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask; // task为null
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            // 执行getTask()方法从延迟队列中获得任务
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        // 执行run()方法
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

ScheduledFutureTask 内部类中的run方法：

代码块

        // 重写run 方法 实现 到达周期后 任务入队
        public void run() {
            boolean periodic = isPeriodic();
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            else if (!periodic)
                ScheduledFutureTask.super.run();

            // runAndReset执行最初设置的Runnable代码，若代码成功执行，则返回true，否则返回false（runnable中的代码拋出异常）。
            // 而只有当返回true时，执行reExecutePeriodic代码  把下次的任务添加进入队列 
            else if (ScheduledFutureTask.super.runAndReset()) {
                // 设置下次执行时间
                setNextRunTime();
                // 任务重新入队
                reExecutePeriodic(outerTask);
            }
        }

下次任务执行时间依赖上次任务执行耗时

任务执行中有一次 遇到异常 则线程死掉 后续也不会再往队列中增加任务

// 任务重新入队方法： reExecutePeriodic()

代码块

    void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(true)) {
            super.getQueue().add(task);
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

reExecutePeriodic 以及delayedExecute 均调用了super.getQueue().add(task)行代码，

ScheduledThreadPoolExecutor类在内部自己实现了一个基于堆数据结构的延迟队列。add方法最终会落到offer方法中

代码块

public boolean add(Runnable e) {
            return offer(e);
        }

        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;
                // 队列大小不足 扩容
                if (i >= queue.length)
                    grow();
                // 更新队列大小
                size = i + 1;
                // 如果当前队列中无任务  直接加入队列头 无需调整
                if (i == 0) {
                    // 任务加入队列头
                    queue[0] = e;
                    // 记录索引  用于加速取消任务？
                    setIndex(e, 0);
                } else {
                    //把任务加入堆中，并调整堆结构，这里就会根据任务的触发时间排列
                    //把需要最早执行的任务放在前面
                    siftUp(i, e);
                }
                //如果新加入的元素就是队列头，这里有两种情况
                //1.这是用户提交的第一个任务
                //2.新任务进行堆调整以后，排在队列头
                if (queue[0] == e) {
                    //这个变量起优化作用，后面说
                    leader = null;
                    //加入元素以后，唤醒worker线程
                    available.signal();
                }
            } finally {
                lock.unlock();
            }
            return true;
        }

runWorker()中调用的getTask() 方法：

代码块

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        // 循环重试获取任务
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            // 校验任务状态
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            // 线程数目 超过最大线程数  或 (（超过核心线程数 或 允许核心线程超时)且已超时 且 （线程数>1 或队列为空） ) 执行回收线程  
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                Runnable r = timed ?
                    // 有超时时间的获取队列任务
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    // 无限期阻塞获取队列任务
                    workQueue.take();
                if (r != null)
                    return r;
                // 没有拿到任务  认为超时了
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

workQueue.take();：延迟队列中的take 方法

代码块

public RunnableScheduledFuture<?> take() throws InterruptedException {
            final ReentrantLock lock = this.lock;
            lock.lockInterruptibly();
            try {
                // 循环重试
                for (;;) {
                    // 仅仅获取队头元素  不出队列
                    RunnableScheduledFuture<?> first = queue[0];
                    if (first == null)
                        // 队列中任务为空 执行await() 阻塞等待  await() 会释放锁资源
                        available.await();
                    else {
                        //成功拿到任务

                         //计算任务执行时间，这个delay是 任务触发时间 减去当前时间
                        long delay = first.getDelay(NANOSECONDS);
                        // 到了触发时间，则执行出队操作
                        if (delay <= 0)
                            return finishPoll(first);
                        first = null; // don't retain ref while waiting
                        //这里表示该任务已经分配给了其他线程，当前线程等待唤醒就可以  其他线程拿到最新任务正在执行作为leader
                        if (leader != null)
                            available.await();
                        else {
                            //否则把给任务分配给当前线程
                            Thread thisThread = Thread.currentThread();
                            leader = thisThread;
                            try {
                                //当前线程等待任务剩余延迟时间
                                available.awaitNanos(delay);
                            } finally {
                                //这里线程醒来以后，什么时候leader会发生变化呢？
                                //就是上面的添加任务的时候
                                // 重置leader  重新循环拿任务
                                if (leader == thisThread)
                                    leader = null;
                            }
                        }
                    }
                }
            } finally {
                //如果队列不为空，则唤醒其他woker线程
                if (leader == null && queue[0] != null)
                    available.signal();
                lock.unlock();
            }
        }

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

leader 变量优化多个线程执行任务时的等待逻辑

这里为什么会加入一个leader变量来分配阻塞队列中的任务呢？原因是要减少不必要的时间等待。

比如说现在队列中的第一个任务1分钟后执行，那么用户提交新的任务时会不断的加入woker线程，如果新提交的任务都排在队列后面，

也就是说新的woker现在都会取出这第一个任务进行执行延迟时间的等待，当该任务到触发时间时，会唤醒很多woker线程，这显然是没有必要的。