Jaca定时任务-01-进程级别的Timer,ScheduledExecutorService,springtask

已于 2022-08-11 09:48:13 修改
阅读量486 收藏
点赞数 1
分类专栏： java定时任务 文章标签： java spring 前端
于 2022-07-04 11:24:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41694906/article/details/125594085
版权

文章目录


系列文章：
Jaca定时任务-02-Quartz

1：定时任务比较

1：定时任务实现的几种方式-进程级别的：

1、Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
2、ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
3、Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。配置简单功能较多，如果系统使用单机的话可以优先考虑spring定时器

2：定时任务实现的几种方式-支持分布式的：

4、Quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。可支持分布式
5.elastic-job：当当开发的弹性分布式任务调度系统，功能丰富强大，采用zookeeper实现分布式协调，实现任务高可用以及分片，目前是版本2.15，并且可以支持云开发
6.xxl-job: 是大众点评员工徐雪里于2015年发布的分布式任务调度平台，是一个轻量级分布式任务调度框架，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。

2：Timer

  1. 单线程执行，任务可能相互堵塞
  2. 运行时异常会导致timer线程终止
package com.Timer;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * @author wkl
 * @create 2022-07-04 9:57
 */
public class TimerTest {
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task  run:" + new Date());
            }
        };

        /**
         * 如果指定开始执行的时间在当前系统运行时间之前，scheduleAtFixedRate会把已经过去的时间也作为周期执行，而schedule不会把过去的时间算上。
         */
        //安排指定的任务在指定的时间开始进行重复的固定延迟执行。这里是每3秒执行一次
        Timer timer = new Timer();
        //下次执行任务的时间取决于上次执行完成的时间
        timer.schedule(timerTask, 5000, 3000);
        //
//        timer.scheduleAtFixedRate(timerTask,10,3000);
    }

   

    public static void testTimer1() {
        //第一种方法:设定任务 task在指定时间 time执行
        // schedule(TimerTask task,Date time);
        // schedule(TimerTask task, Date time)
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("设定要执行的任务");
            }
        }, 20000);//设定的时间 time，此处为毫秒
    }

    public static void testTimer2() {
        //第二种方法：设定指定任务task在指定延迟 delay后，固定频率 period执行
        //schedule(TimerTask task, long delay, long period)
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("我被执行了");
            }
        }, 3000, 3);
    }

    public static void testTimer3() {
        //和上边的用法一样，只不过利用calendar日历类，强行做成了根据固定值时间执行
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, 12);//控制时
        calendar.set(Calendar.MINUTE, 0);      //控制分
        calendar.set(Calendar.SECOND, 0);      //控制秒
        Date time = calendar.getTime();        // 得出执行任务的时间,此处为今天的12：00：00
        new Timer().scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("-------设定要指定任务--------");
            }
        }, time, 1000 * 60 * 60 * 24);//这里设定将延迟每天固定执行
    }
}

2：使用ScheduledExecutorService开多线程执行

  1. 使用多线程执行任务，不会相互阻塞
  2. 如果线程失活，会创建新的线程执行任务，抛异常，丢弃异常任务
package com.Timer.pool;

import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 用java.util.concurrent.ScheduledExecutorService 来实现定时任务
 * @author wkl
 * @create 2022-07-04 10:16
 */
public class Scheduled {
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task  run:" + new Date());
            }
        };

        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        //                          执行任务    延迟时间        时间间隔    时间单位
        service.scheduleAtFixedRate(timerTask, 5, 3, TimeUnit.SECONDS);
    }

}

3：使用Spring Task-Spring 3.0以后自带的task 调度工具

1：注解使用

1：任务执行类

package com.job.SpringTask;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @author wkl
 * @create 2022-07-04 10:35
 */
@Component
@EnableScheduling
@Async("executor")
public class SpringTaskTest {

    @Scheduled(cron = "*/5 * * * * ?")
    public void test1 (){
        System.out.println("每5秒执行一次："+new Date());
    }
}

2：线程池配置类

package com.job.SpringTask;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/**
 * springtask设置类,设置springtask任务线程池
 *
 * @author wkl
 * @create 2022-07-04 10:56
 */
@Configuration
@EnableAsync
public class AsycConfig {
    /*
   此处成员变量应该使用@Value从配置中读取
    */
    private int corePoolSize = 10;
    private int maxPoolSize = 200;
    private int queueCapacity = 10;

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

3：参数说明

使用@Async开启异步模式，@Async的值为执行器executor，名字需要与xml中配置的一致。
executor用于配置线程池
pool-size：线程池数量，可以设置范围，也可以设置指定值，最小值为1，最大值为Integer.MAX_VALUE。
queue-capacity：任务队列，当线程数达到最小值时，新任务将会被放到队列中。当队列被占满时，executor就会在线程池中创建新的线程，执行新的任务。
keep-alive：pool-size的最小值是指核心线程的数量，超过这个数的其他线程，当执行完任务后，可以存活keep-alive指定的时间，单位毫秒。
rejection-policy：当线程数达到最大值时，系统的处理策略，可以设置4种方式:
ABOAT：默认值，抛出异常，不再执行新的任务，直到有空闲线程可以使用
DISCARD：不抛出异常，不再执行新的任务，知道有空闲线程可以使用
CALLER_RUNS：在当前线程中执行新的任务
DISCARD_OLDEST：丢弃最旧的一个任务，空出线程执行新的任务

2：xml配置使用

1：任务执行类

package com.sawyer.job;
import java.util.Date;

public class TaskTest {
    public void run() {
        System.out.println(new Date() + " and current thread is " + Thread.currentThread().getName());
    }
}

2：在xml中声明bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

    <!-- task -->
    <bean id="taskTest" class="com.sawyer.job.TaskTest"/>
    <task:scheduled-tasks>
        <task:scheduled ref="taskTest" method="run" cron="0/5 * * * * ?" />
    </task:scheduled-tasks>
</beans>

3：xml配置线程池

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

    <!-- task -->
    <context:component-scan base-package="com.sawyer.job"/>
    <task:executor id="executor" pool-size="10-15" queue-capacity="10" keep-alive="30000" rejection-policy="DISCARD"/>
    <task:scheduler id="scheduler" pool-size="10"/>
    <task:annotation-driven executor="executor" scheduler="scheduler"/>
</beans>

4：参数说明

1：在xml中声明taskbean时

  • scheduled-tasks中可以定义多个task，这里指定了一个task，上图中 ref 指定任务类，method指定执行方法，cron指定频率，这里表示每隔5秒执行一下。
  • task中用于指定时间频率的方式，有以下几种：
    • cron：cron表达式十分强大，可以指定秒、分、时、日期、月份、星期几，格式为 * * * * * ？
    • fixed-rate：单位毫秒，每隔指定时间就执行一次
    • fixed-delay：单位毫秒，上次任务执行完后，间隔指定时间后执行下次任务
    • initial-delay：单位毫秒，首次执行任务的时候，延迟指定时间执行。
  • spring task 默认使用的是同步模式，即上次任务执行完后，才会执行下次任务。上述时间频率只有在非同步模式下才会完全符合，在同步模式下，实际计算方式为：
    • fixed-rate ：任务的实际执行时间+fixedRate时间之后，执行下次任务
    • fixed-delay：任务的实际执行时间如果小于fixedDelay，则时间间隔为fixedDelay；如果任务的实际执行时间大于fixedDelay，则上次任务执行完后，立即执行下一次任务。

2：在xml中配置线程池

  • 使用@Async开启异步模式，@Async的值为执行器executor，名字需要与xml中配置的一致。
  • executor用于配置线程池
  • pool-size：线程池数量，可以设置范围，也可以设置指定值，最小值为1，最大值为Integer.MAX_VALUE。
  • queue-capacity：任务队列，当线程数达到最小值时，新任务将会被放到队列中。当队列被占满时，executor就会在线程池中创建新的线程，执行新的任务。
  • keep-alive：pool-size的最小值是指核心线程的数量，超过这个数的其他线程，当执行完任务后，可以存活keep-alive指定的时间，单位毫秒。
  • rejection-policy：当线程数达到最大值时，系统的处理策略，可以设置4种方式:
    • ABOAT：默认值，抛出异常，不再执行新的任务，直到有空闲线程可以使用
    • DISCARD：不抛出异常，不再执行新的任务，知道有空闲线程可以使用
    • CALLER_RUNS：在当前线程中执行新的任务
    • DISCARD_OLDEST：丢弃最旧的一个任务，空出线程执行新的任务

3:Cron表达式

1：CronTrigger配置格式:

格式: [秒] [分] [小时] [日] [月] [周] [年]
在这里插入图片描述

2：通配符说明:

  • [* ] 表示所有值. 例如:在分的字段上设置 “*”,表示每一分钟都会触发。
  • ? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?
    • 表示区间。例如 在小时上设置 “10-12”,表示 10,11,12点都会触发。
  • , 表示指定多个值，例如在周字段上设置 “MON,WED,FRI” 表示周一，周三和周五触发
  • / 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置’1/3’所示每月1号开始，每隔三天触发一次。
  • L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"
  • W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 “1W”,它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，“W"前只能设置具体的数字,不允许区间”-").
  • 【#】序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)
    tips

3：举例说明

表达式说明
0 0 12 * * ?每天12点触发
0 15 10 ? * *每天10点15分触发
0 15 10 * * ?每天10点15分触发
0 15 10 * * ? *每天10点15分触发
0 15 10 * * ?2005 2005年每天10点15分触发
0 * 14 * * ?每天下午的 2点到2点59分每分触发
0 0/5 14 * * ?每天下午的 2点到2点59分(整点开始，每隔5分触发)
0 0/5 14,18 * * ?每天下午的 2点到2点59分(整点开始，每隔5分触发)每天下午的 18点到18点59分(整点开始，每隔5分触发)
0 0-5 14 * * ?每天下午的 2点到2点05分每分触发
0 10,44 14 ? 3 WED3月分每周三下午的 2点10分和2点44分触发
0 15 10 ? * MON-FRI从周一到周五每天上午的10点15分触发
0 15 10 15 * ?每月15号上午10点15分触发
0 15 10 L * ?每月最后一天的10点15分触发
0 15 10 ? * 6L每月最后一周的星期五的10点15分触发
0 15 10 ? * 6L 2002-2005从2002年到2005年每月最后一周的星期五的10点15分触发
0 15 10 ? * 6#3每月的第三周的星期五开始触发
0 0 12 1/5 * ?每月的第一个中午开始每隔5天触发一次
0 11 11 11 11 ?每年的11月11号 11点11分触发(光棍节)

4：在线cron表达式生成： http://qqe2.com/cron/inde

苍煜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java Timer 定时每天凌晨1点执行任务
08-25
主要介绍了java Timer 定时每天凌晨1点执行任务的代码，代码简单易懂，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
Timer和ScheduledExecutorService
程序员备忘录
12-04 640
java.util.Timer计时器有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。但是，Timer存在一些缺陷，因此你应该考虑使用ScheduledThreadPoolExecutor作为代替品,Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支持相对时
timer与ScheduledExecutorService
az44yao的专栏
12-31 1394
Timer和ScheduledExecutorService都可以用来做定时任务，有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。但至从JDK1.5之后，建议采用ScheduledExecutorService。 原因如下： 1、Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;但Schedu
Timer+TimerTask的升级版ScheduledExecutorService
haoyuegongzi的博客
11-17 490
ScheduledExecutorService是一个接口，是继承于接口ExecutorService的子类，而ExecutorService又是继承于Executor接口的子类。 这里我们先从继承的最终类Executor接说起。 Executor接口只有一个方法：void execute(Runnable command);他是一个同步方法，接收一个Runnable接口作为参数。具体由imple...
Timer与ScheduledExecutorService
热门推荐
nuoWei_SenLin的博客
11-25 1万+
Timer与ScheduleExecutorService，二者都代表定时任务。 Timer： public static void main(String[] args) { Timer timer = new Timer(); //继承TimerTask抽象类，覆写run方法，表示一个任务 MyTimerTask timerTask = new MyTimerTask();
spring-timer-quartz.zip_namegnd_spring定时任务
09-21
使用spring实现定时任务，整合spring，springmvc,实现定时任务执行
java定时任务Timer和TimerTask使用详解
08-31
主要为大家详细介绍了java定时任务Timer和TimerTask使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java定时任务：利用java Timer类实现定时执行任务的功能
09-01
本篇文章主要介绍了利用java Timer类实现定时执行任务的功能，具有一定的参考价值，有需要的可以了解一下。
Java--Timer--TimerTask--.rar_java timer
09-24
这是Java两种功能的比较。。。里面涉及到一些使用
java多线程-Timer和ScheduledExecutorService
epitomizelu的专栏
07-07 257
当需要对线程进行时间上的调度时，Java提供了两种方案： Timer + TimerTask ScheduledExecutorService 区别： Timer有很大的局限性，内部只有一个工作线程，如有个线程需要调度时，只能串行执行。 ScheduledExecutorService提供线程池，可以并行的进行任务调度。 Timer案例： package thread; import java.util.Timer; import java.util.TimerTask; public class
Timer 与ScheduledExecutorService 的使用和区别
weixin_33873846的博客
02-06 89
2019独角兽企业重金招聘Python工程师标准>>> ...
定时调度Timer与ScheduledExecutorService的使用与源码解析
Stay Hungry,Stay Foolish
07-07 1万+
1.如何实现指定时间执行任务？2.如何实现按指定周期执行任务？3.Timer与ScheduledExecutorService的区别是什么？本文将介绍定时调度Timer与ScheduledExecutorService的使用及源码解析。
Springboot中使用定时器（Timer、ScheduledExecutor、@Scheduled、Quartz）
qq_39291028的博客
06-21 7179
目录 Timer ScheduledExecutor 注解@Scheduled Quartz 因为某些需求，要在特定的时间执行一些任务，比如定时删除服务器存储的数据缓存，定时获取数据以及定时发送推送等等，这时就需要用到定时任务了。定时任务，指的是在编程过程中无须做复杂控制的前提下执行简单的定时操作。 Timer 在java中一个完整的定时任务可以用Timer和TimerTask两个类...
jar包增量更新分析
junlaiyan的专栏
05-16 253
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 617
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
最新发布
yzqy_的博客
05-16 901
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 904
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
使用ScheduledExecutorService代替Timer实现动态启动定时任务
11-25
以下是使用ScheduledExecutorService代替Timer实现动态启动定时任务的代码示例： ```java import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService; import java.util....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苍煜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值