Java定时任务线程池ScheduledThreadPoolExecutor

最新推荐文章于 2024-12-05 08:35:10 发布
原创 最新推荐文章于 2024-12-05 08:35:10 发布 · 3k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #并发 #定时任务线程池 #解析

本文深入探讨Java中的ScheduledThreadPoolExecutor，一种用于执行定时任务的线程池。讲解了其核心方法如scheduleAtFixedRate和scheduleWithFixedDelay的使用，分析了源码中关键的延迟队列和执行流程，对比了不同定时任务的区别。

Java并发定时任务线程池--------定时任务ScheduledThreadPoolExecutor

我们了解的ThreadPoolExecutor是java的普通线程池,而ScheduledThreadPoolExecutor是java提供的定时任务线程池。今天就跟大家谈一下我对定时线程池ScheduledThreadPoolExecutor的理解。

ScheduledThreadPoolExecutor的使用
常用
java.util.concurrent.ScheduledThreadPoolExecutor#schedule 定时任务
java.util.concurrent.ScheduledThreadPoolExecutor#scheduleAtFixedRate 固定速率连续执行
java.util.concurrent.ScheduledThreadPoolExecutor#scheduleWithFixedDelay非固定速率连续执行
java.util.concurrent.ScheduledThreadPoolExecutor.DelayedWorkQueue延迟队列
源码分析：

在这里插入图片描述

初始化ScheduledThreadPoolExecutor

调度核心构造器

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

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<Void> sft =
        new ScheduledFutureTask<Void>(command,
                                      null,
                                      triggerTime(initialDelay, unit),
                                      unit.toNanos(period));//处理时间
    RunnableScheduledFuture<Void> t = decorateTask(command, sft); 
    sft.outerTask = t;
    delayedExecute(t);    return t;
}

delayedExecute#ScheduledThreadPoolExecutor方法

if (isShutdown())
    reject(task);
else {
    super.getQueue().add(task);//增加任务 子类实现了
//总结：add方法是通过DelayedWorkQueue（初始化时候指定的队列） 延迟队列实现 offer获取对象的延迟

    if (isShutdown() &&
        !canRunInCurrentRunState(task.isPeriodic()) && //判断是否已经停止
        remove(task))
        task.cancel(false);
    else
        ensurePrestart();
}

Offer#DelayedWorkQueue 二叉树堆排序算法

public boolean offer(Runnable x) {
    if (x == null)
        throw new NullPointerException();
    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); //第一个直接设置索引和下标0
        } else {
            siftUp(i, e);//看这儿 
        }
        if (queue[0] == e) {
            leader = null;
            available.signal();//唤醒 }
    } finally {
        lock.unlock();
    }
    return true;
}

siftUp#DelayedWorkQueue保证相同的

while (k > 0) {
    int parent = (k - 1) >>> 1; 
    RunnableScheduledFuture<?> e = queue[parent];
    if (key.compareTo(e) >= 0)
        break; 
    queue[k] = e;
    setIndex(e, k);
    k = parent;
}
queue[k] = key;
setIndex(key, k);

compareTo#ScheduledFutureTask

if (other == this) // compare zero if same object
    return 0;
if (other instanceof ScheduledFutureTask) {
    ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
    long diff = time - x.time; //判断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;

我们在回到开始的地方,根据刚才我们跟代码可以看到执行时间的顺序已经分配好了，那如何确保work可以运行了？
确保有work执行

ensurePrestart#ThreadPoolExecutor

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

放到队列 runwork take对象

take#DelayedWorkQueue

//调用start>run>runWorker->getTask>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(TimeUnit.NANOSECONDS);//到时间了
                if (delay <= 0)//到时间了
                    return finishPoll(first);
                else if (leader != null)
                    available.await();//因为没有执行线程初始化，所以等等什么时候有了自己被他人唤醒
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay);//各种condition的awaitNanos 带时间的
                    } finally {
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && queue[0] != null)
            available.signal();
        lock.unlock();
    }
}

finishPoll#ScheduledThreadPoolExecutor

private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) {
    int s = --size;
    RunnableScheduledFuture x = queue[s];//重新排列
    queue[s] = null;
    if (s != 0)
        siftDown(0, x);
    setIndex(f, -1);
    return f;
}
区别scheduleAtFixedRate 和scheduleWithFixedDelay 有什么区别吗？

（构造方法中实现了ScheduledFutureTask）

run#ScheduledFutureTask

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);// 重置task 没有异常捕捉
    }
}

setNextRunTime#ScheduledFutureTask

long p = period;
if (p > 0)  //看这个大于0 和小于0的区别
    time += p;  //假如延迟了这个时间早过了，+当前时候肯定还是过的。
else
    time = triggerTime(-p); //取的当前的任务延迟

参数
task–这是被调度的任务。
delay–这是以毫秒为单位的延迟之前的任务执行。
period–这是在连续执行任务之间的毫秒的时间。

实战：

实战与工作中注意事项
有异常一定要捕获，要不job不会执行了

单列模式（Double check lock）

双重锁定
发布与逸出这块以单列模式举例，在高并发下如何实现一个线程安全的单列模式。
会涉及到这些知识点1、懒汉模式、2、饿汉模式、3、synchronized 4、volatile 5、枚举、6重排序等
内部类
枚举类

AbstractQueuedSynchronizer(AQS)同步器:

公平锁、非公平锁
NonfairSync

cpu 随机调用task

在这里插入图片描述
在这里插入图片描述

总体来说，ScheduedThreadPoolExecutor的重点是要理解下次执行时间的计算，以及优 先队列的出队、入队和删除的过程，这两个是理解ScheduedThreadPoolExecutor的关 键。

(二十)java多线程之ScheduledThreadPoolExecutor
天之妖星的专栏
11-03 1万+
本人邮箱: kco1989@qq.com 欢迎转载,转载请注明网址 http://blog.csdn.net/tianshi_kco github: https://github.com/kco1989/kco 代码已经全部托管github有需要的同学自行下载 引言java 提供的线程池还有一个,那就是任务调度线程池ScheduledThreadPoolExecutor,它其实是T
【java】java 定时任务线程池 ScheduledThreadPoolExecutor 源码阅读
九师兄
03-10 701
继承自，为任务提供延迟或周期执行，属于线程池的一种。使用专门的任务类型—ScheduledFutureTask来执行周期任务，也可以接收不需要时间调度的任务(这些任务通过 ExecutorService 来执行)。使用专门的存储队列—DelayedWorkQueue 来存储任务，DelayedWorkQueue 是无界延迟队列DelayQueue 的一种。相比ThreadPoolExecutor也简化了执行机制(delayedExecute方法，后面单独分析)。
图解java.util.concurrent并发包源码系列——深入理解定时任务线程池ScheduledThreadPoolExecutor
weixin_43889578的博客
12-02 1768
到这里，整个ScheduledThreadPoolExecutor的原理和源码都分析完毕了。用了一个延时队列DelayedWorkQueue去存放任务，延时队列又使用一个小顶堆去存放任务，小顶堆中的任务ScheduledFutureTask会按照到期时间time从小到大进行排序。当我们提交定时任务到ScheduledThreadPoolExecutor时，任务会被放入小顶堆中，然后会从底往上做堆调整。任务放入堆中之后，检查是否有必要创建新线程，如果有必要则创建新线程。
Java并发编程(十九)：ScheduledThreadPoolExecutor总结与源码分析
黄智霖的博客
05-09 8695
目录前言使用源码分析 前言   ScheduledThreadPoolExecutor主要用于处理延时任务或者定时任务，在平时的工作场景中也有被广泛应用，而我们有了前文关于ThreadPoolExecutor源码的深入理解，这里理解ScheduledThreadPoolExecutor便会顺畅不少。 使用 ScheduledThreadPoolExecutor的使用还是比较简单，总体来说主要有三种方式提交任务： schedule： scheduleAtFixedRate： scheduleWithFixe
java多线程学习-java.util.concurrent详解(三)ScheduledThreadPoolExecutor
For that dream
10-13 1491
6. ScheduledThreadPoolExecutor     我们先来学习一下JDK1.5 API中关于这个类的详细介绍：     "可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求 ThreadPoolExecutor 具有额
定时任务之ScheduledThreadPoolExecutor
祈雨v的博客
05-23 3829
java自带的定时任务执行器为ScheduledThreadPoolExecutor，继承于线程池管理器ThreadPoolExecutor，常用方法如下，程序将每2秒输出一次系统时间。 ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(2); executor.scheduleAtFixedRate(ne...
java 定时器线程池（ScheduledThreadPoolExecutor）的实现
08-19
Java定时器线程池，即`ScheduledThreadPoolExecutor`，是Java并发编程中一个重要的工具，它继承自`ThreadPoolExecutor`并扩展了定时和周期性任务的执行能力。`ScheduledThreadPoolExecutor`提供了定时执行、延迟执行...
Java-什么是定时任务线程池？
兴趣是最好的老师
08-21 408
创建定时任务线程池：使用 Executors.newScheduledThreadPool() 方法创建一个定时任务线程。提交任务：使用 scheduleAtFixedRate 方法提交任务到线程池，该任务每隔一秒执行一次。提交任务：使用 scheduleAtFixedRate 方法提交任务到线程池，该任务每隔一秒执行一次。关闭线程池：使用 shutdown 方法关闭线程池，并等待所有任务完成。下面是一个使用上述工具类创建定时任务线程池并执行任务的示例。建定时任务线程池，这里设置了线程池大小为 3。
ScheduledThreadPoolExecutor：定时任务线程池详解
12-05 1788
本文主要介绍了Java定时任务线程池ScheduledThreadPoolExecutor的相关知识，包括主要用途，使用案例，实现原理，主要方法等内容。
JAVA多线程(二十三)Java多线程之ScheduledThreadPoolExecutor定时执行任务线程池
yuan_xw的专栏
02-03 1297
1.JAVA多线程(二十三)Java多线程之ScheduledThreadPoolExecutor定时执行任务线程池 1.1 定时执行任务线程池ScheduledThreadPoolExecutor    ScheduledThreadPoolExecutor是一个使用线程池执行定时任务的类，相较于Java中提供的另一个执行定时任务的类Timer，其主要有如下两个优点： 使用多线程执行任务，不用...
JAVA线程池:ScheduledThreadPoolExecutor
热门推荐
青衫烟雨客的专栏
08-05 1万+
前言 自JDK1.5开始，JDK提供了ScheduledThreadPoolExecutor类来支持周期性任务的调度。在这之前的实现需要依靠Timer和TimerTask或者其它第三方工具来完成。但Timer有不少的缺陷： Timer是单线程模式； 如果在执行任务期间某个TimerTask耗时较久，那么就会影响其它任务的调度； Timer的任务调度是基于绝对时间的，对系统时间敏感； Timer不会捕获执行TimerTask时所抛出的异常，由于Timer是单线程，所以一旦出现异常，则线程就会终止，其
java.util.concurrent.ScheduledThreadPoolExecutor 源码
weixin_33982670的博客
11-29 1686
2019独角兽企业重金招聘Python工程师标准>>> ...
Java线程池架构2-多线程调度器
novelly的专栏
01-08 755
http://ifeve.com/java线程池架构2-多线程调度器（scheduledthreadpoolexecutor）/ 在前面介绍了java的多线程的基本原理信息：《Java线程池架构原理和源码解析(ThreadPoolExecutor)》，本文对这个java本身的线程池的调度器做一个简单扩展，如果还没读过上一篇文章，建议读一下，因为这是调度器的核心组件部分。  我们如果
Java 线程 — ScheduledThreadPoolExecutor
weixin_34025051的博客
11-22 184
ScheduledThreadPoolExecutor 该类继承自ThreadPoolExecutor，增加了定时执行线程和延迟启动的功能，这两个功能是通过延时队列DelayedWorkQueue辅助实现的。 线程池里面的线程需要从队列里面获取任务，任务根据延时时长是有顺序的，线程池的线一直获取延时最短的任务，也就是最小二叉堆中的堆顶元素，这个时候堆顶元素成为各个线程争夺的资源， 在获取堆顶元素...
Java进阶篇--线程池之ScheduledThreadPoolExecutor
m0_74293254的博客
11-07 1618
ScheduledThreadPoolExecutor简介ScheduledThreadPoolExecutor简介ScheduledThreadPoolExecutor继承自ThreadPoolExecutor（），并实现了ScheduledExecutorService接口，因此它同时具备了线程池的基本功能和任务调度的功能。ScheduledThreadPoolExecutor可以用来延迟执行任务或者周期性执行任务，相比于传统的Timer类，其功能更加强大和灵活。
定时线程池ScheduledThreadPoolExecutor
lizc_lizc的博客
11-09 396
文章目录简介内部类主要方法总结 简介 ScheduledThreadPoolExecutor 继承了 ThreadPoolExecutor 并实现了ScheduledExecutorService接口 。线程池队列是DelayedWorkQueue，它和 DelayedQueue原理类似，都是一个延迟队列。在ScheduledThreadPoolExecutor中阻塞队列存储的是Scheduled...
JAVA 定时器 ScheduledThreadPoolExecutor
javaEE 专栏 + 琐事小计
06-13 273
[code="java"] ... //定时器 ScheduledThreadPoolExecutor monitorService = new ScheduledThreadPoolExecutor(10, new ThreadFactoryBuilder().setNameFormat("lifecycleSupervisor-" + Thread.currentThread()...
ScheduledThreadPoolExecutor Java
huzuoliang
03-08 514
Java提供的Time类可以周期性地或者延期执行任务，但是有时我们需要并行执行同样的任务，这个时候如果创建多个Time对象会给系统带来负担，解决办法是将定时任务放到线程池中执行。Java的ScheduledThreadPoolExecutor类实现了ScheduledExecutorService接口中定义的以不同方法执行任务的方法。Executors类提供了工厂方法创建ScheduledThrea
若依定时任务线程池配置问题如何解决
最新发布
10-25
若依是基于 Spring Boot 和 Spring Cloud 构建的开源项目，其定时任务线程池配置问题可参考 Spring 框架的相关配置方法。以下是几种可能的解决方法： #### 利用 SchedulingConfigurer 接口配置线程池 可以通过实现 `SchedulingConfigurer` 接口来定制定时任务的线程池。示例代码如下： ```java import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.SchedulingConfigurer; import org.springframework.scheduling.config.ScheduledTaskRegistrar; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; @Configuration public class MySchedulingConfigurer implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { // 设定长度为 5 的定时任务线程池 ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5); taskRegistrar.setScheduler(scheduledExecutorService); } } ``` 此配置会创建一个大小为 5 的定时任务线程池，从而让多个定时任务能够并行执行[^2]。 #### 使用 ThreadPoolTaskScheduler 配置线程池 还能使用 `ThreadPoolTaskScheduler` 来配置线程池，示例代码如下： ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.TaskScheduler; import org.springframework.scheduling.annotation.SchedulingConfigurer; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import org.springframework.scheduling.config.ScheduledTaskRegistrar; @Configuration public class ScheduleConfig implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { taskRegistrar.setScheduler(taskScheduler()); } @Bean public TaskScheduler taskScheduler() { ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler(); taskScheduler.setPoolSize(4); taskScheduler.setThreadNamePrefix("scheduler-pool-"); return taskScheduler; } } ``` 该配置会创建一个大小为 4 的线程池，并且给线程设置了前缀 `scheduler-pool-`，方便进行日志跟踪和调试[^3]。 #### 自定义定时任务线程池 可以通过工具类创建自定义的定时任务线程池，示例代码如下： ```java import java.util.concurrent.*; public class CustomScheduledThreadPoolExample { public static void main(String[] args) { // 创建自定义定时任务线程池 ScheduledThreadPoolExecutor scheduledThreadPool = ThreadPoolUtil.createScheduledThreadPool(3, "CustomScheduledThreadPool-"); // 提交任务到定时任务线程池 scheduledThreadPool.scheduleAtFixedRate(() -> { System.out.println("Hello from scheduled task! Running on thread: " + Thread.currentThread().getName()); try { Thread.sleep(1000); // 模拟任务执行 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, 0, 1, TimeUnit.SECONDS); // 每隔一秒执行一次 // 关闭线程池 scheduledThreadPool.shutdown(); try { scheduledThreadPool.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } ``` 此示例创建了一个大小为 3 的自定义定时任务线程池，并且提交了一个每隔一秒执行一次的任务[^1]。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值