定时任务

最新推荐文章于 2022-12-14 16:53:56 发布
最新推荐文章于 2022-12-14 16:53:56 发布
阅读量242 收藏
点赞数
分类专栏： 定时任务 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Trygoto/article/details/114986530
版权

定时任务

简介：

日常生活中有多定时任务的应用场景，比如闹钟每天指定时间叫你起床，比如监控系统，隔断时间采集数据，对异常报警。

TimerTask和Timer:

TimerTask表示的时一个定时任务类，它是一个抽象类,实现了runnable接口，具体的定时任务类需要继承该类，实现run方法。

Timer:具体执行类，负责定时任务的调度和执行。Timer内部是有一任务队列和Timer线程组成。任务队列是一个基于堆实现的优先级队列，按照下次执行时间排优先级。因为只有一个线程，所有有时候任务会被延迟处理，且Timer线程主体是一个循环，循环处理任务队列中的任务。

Timer常用的方法：

方法名返回值说明
schedule(TimerTask task,Date time)void在绝对时间点执行任务
schedule(TimerTask task,long delay)void在当前时间延时delay毫秒后运行
schedule(TimerTask task,Date firstTime,long period)void固定延时重复执行，第一次执行时间时firstTime, 后面执行时间是上一次实际执行时间+period
schedule(TimerTask task,long delay,long period)固定延时重复执行， 当前时间+delay为第一次执行之间，后面的都是实际执行时间加period
scheduleAtFixedRate(TimerTask,Date firstTime，long period)void固定频率执行，第一次执行时间是firstTime,后面执行时间都是前一次实际执行时间+period
scheduleAtFixedRate(TimerTask,long delay，long period)void固定频率执行，第一次执行时间是当前时间+delay，后面每一次执行都是前一次实际执行时间+period
public class TimedTask {
    static class MyTimerTask extends TimerTask {

        @Override
        public void run() {
            System.out.println("定时任务1");
            try {
                Thread.sleep(2000);
            }catch (InterruptedException i){
                i.printStackTrace();
            }
            System.out.println("执行完毕");
        }
    }

    static class MineTimerTask extends TimerTask {

        @Override
        public void run() {
            System.out.println("定时任务2");
        }
    }
    static class LockTimerTask extends  TimerTask {

        @Override
        public void run() {
            while(true){
                System.out.println("定时任务会有死循环");
            }
        }
    }

    static class ExceptionTimerTask extends TimerTask {

        @Override
        public void run() {
            System.out.println("发生异常后所有定时任务都会被取消");
            throw new RuntimeException();
        }
    }
    public static void main(String[] args) throws Exception {
        Timer timer = new Timer();
        MyTimerTask myTimerTask = new MyTimerTask();
        MineTimerTask mineTimerTask = new MineTimerTask();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //指定绝对时间执行任务
        timer.schedule(myTimerTask,simpleDateFormat.parse("2021-3-17 10:33:00"));
        //当前时间加指定延时毫秒时间执行任务
        timer.schedule(myTimerTask,1000);
        //指定第一次执行时间按固定的延时时间重复执行
        timer.schedule(myTimerTask,simpleDateFormat.parse("2021-3-17 10:40:00"),1000);
        //当前时间+延时毫秒时间按固定延时时间重复执行
        timer.schedule(myTimerTask,1000,1000);
        //指定第一次执行时间，按固定频率指定的延时时间执行任务
        timer.schedule(myTimerTask,simpleDateFormat.parse("2021-3-17 10:42:00"),1000);
        //当前时间+延时时间按固定频率重复执行
        timer.schedule(myTimerTask,1000,1000);
        //timer内部主要是由任务队列和Timer线程两部分组成。任务队列是一个基于堆实现的优先级队列
        //按照下次执行的时间排优先级。Timer线程负责执行所有的定时任务,需要强调的是，一个Timer
        //对象只有一个Timer线程，所以下面的例子,任务二会延时处理。Timer线程主体是个循环，
        timer.schedule(myTimerTask,1000);
        timer.schedule(mineTimerTask,1000);
        //下面任务2会一下子处理多次任务,因为延时相对的是任务执行前的当前时间，所以固定频率会补足之前等待的时间的频率次数
        timer.schedule(myTimerTask,10);
        timer.scheduleAtFixedRate(mineTimerTask,100,1000);
        //因为Timer只有一个线程，所以当有一个人发生死循环时,后面的任务就永远无法执行了
        timer.schedule(myTimerTask,100,1000);
        LockTimerTask lockTimerTask = new LockTimerTask();
        timer.schedule(lockTimerTask,100,1000);
        //当有一个任务发生异常，后面的所有任务都会被取消，所以一定要在任务重写的run方法内捕获异常
        timer.schedule(myTimerTask,100,1000);
        ExceptionTimerTask exceptionTimerTask = new ExceptionTimerTask();
        timer.schedule(exceptionTimerTask,100,1000);
    }

}

TimerTask 和Timer 的注意点：

(1)Timer调度类内部只有一个线程。内部的队列是基于堆实现的优先级队列。会按照下次执行时间排优先级，但是由于只有一个线程,有时任务会被延迟执行。

(2)固定频率的任务被延迟后，可能会立即执行多次，将次数补够。

(3)固定延时任务的延时相对的时任务执行前的时间,也就是说当上一个任务休眠或者其他原因时，后一个任务会被延时相应的时间。

(4)不可以在任务内部无限循环,会导致后面任务无法执行。

(5)一个定时任务未处理异常就会导致所有任务都被取消。

ScheduledExecutorService:

并发包下的定时任务接口ScheduleExecutorService实现了执行服务接口ExecutorService:它的实现类是scheduledThreadPoolExecutor集成了ThreadPoolExecutor。所以没有了固定频率一下子执行多条的情况第一执行时间是initialDelay后，后面都是加period。而固定延时任务的延时时间也更为合理了，是任务执行之后的时间+period。
同时当一个任务出现异常时也不会影响其他任务，只是发生这个异常的任务被终止。它的任务队列是一个无界的优先级队列,所以做大线程数对它没有作用，即使corePoolSize为0,它也至少有一个线程在运行。

ScheduledThreadPoolExecutor 常用方法：

//单次执行Runnable任务，执行时间是当前时间+delay
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
        if (command != null && unit != null) {
            RunnableScheduledFuture<Void> t = this.decorateTask((Runnable)command, new ScheduledThreadPoolExecutor.ScheduledFutureTask(command, (Object)null, this.triggerTime(delay, unit), sequencer.getAndIncrement()));
            this.delayedExecute(t);
            return t;
        } else {
            throw new NullPointerException();
        }
    }
   //单次执行Callable任务，执行时间是当前时间+delay
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
        if (callable != null && unit != null) {
            RunnableScheduledFuture<V> t = this.decorateTask((Callable)callable, new ScheduledThreadPoolExecutor.ScheduledFutureTask(callable, this.triggerTime(delay, unit), sequencer.getAndIncrement()));
            this.delayedExecute(t);
            return t;
        } else {
            throw new NullPointerException();
        }
    }
 //固定频率执行任务，第一次执行时间是当前时间+initialDelay，后面每次执行时间是执行任务结束后时间+period  
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        if (command != null && unit != null) {
            if (period <= 0L) {
                throw new IllegalArgumentException();
            } else {
                ScheduledThreadPoolExecutor.ScheduledFutureTask<Void> sft = new ScheduledThreadPoolExecutor.ScheduledFutureTask(command, (Object)null, this.triggerTime(initialDelay, unit), unit.toNanos(period), sequencer.getAndIncrement());
                RunnableScheduledFuture<Void> t = this.decorateTask((Runnable)command, sft);
                sft.outerTask = t;
                this.delayedExecute(t);
                return t;
            }
        } else {
            throw new NullPointerException();
        }
    }

//固定重复执行任务，第一次执行时间是当前时间+initialDelay，后面每次执行时间是执行任务结束后时间+period  

    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
        if (command != null && unit != null) {
            if (delay <= 0L) {
                throw new IllegalArgumentException();
            } else {
                ScheduledThreadPoolExecutor.ScheduledFutureTask<Void> sft = new ScheduledThreadPoolExecutor.ScheduledFutureTask(command, (Object)null, this.triggerTime(initialDelay, unit), -unit.toNanos(delay), sequencer.getAndIncrement());
                RunnableScheduledFuture<Void> t = this.decorateTask((Runnable)command, sft);
                sft.outerTask = t;
                this.delayedExecute(t);
                return t;
            }
        } else {
            throw new NullPointerException();
        }
    }

Executors工厂类提供的方法：

//单线程的定时任务
 public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new Executors.DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));
    }
    //单线程的定时任务线程，由自定义线程工厂创建线程
    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new Executors.DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1, threadFactory));
    }

//多线程的定时任务线程，由用户指定线程数
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

//多线程的定时任务线程，由用户指定线程数，由自定义的线程工厂创建线程
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

public class ScheduleExecutorServiceMine {

    static class OrderTimerTask implements Runnable {

        @Override
        public void run() {
            System.out.println("并发定时任务A");
            try {
                Thread.sleep(2000);
            }catch (InterruptedException i){
                i.printStackTrace();
            }
        }
    }

   static class SortTimerTak implements Callable<Integer> {


       @Override
       public Integer call() throws Exception {
           System.out.println("定时任务B");
           return 1;
       }
   }

   static class ExceptionConcurrentTimerTask implements Runnable {

       @Override
       public void run() {
           System.out.println("异常任务");
           throw new RuntimeException();
       }
   }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService scheduleExecutorService =
                (ScheduledExecutorService) new ScheduledThreadPoolExecutor(2);
        OrderTimerTask orderTimerTask = new OrderTimerTask();
        SortTimerTak sortTimerTak = new SortTimerTak();
        //当前时间单次延时执行
        scheduleExecutorService.schedule(orderTimerTask,1000, TimeUnit.MILLISECONDS);
        //返回的ScheduledFuture扩展了异步结果接口Future<V>和Delayed接口
        ScheduledFuture<Integer> future = scheduleExecutorService.schedule(sortTimerTak,1000,TimeUnit.MILLISECONDS);
        System.out.println(future.get());

        ScheduledExecutorService scheduledExecutorService1 = Executors.newScheduledThreadPool(10);
        ExceptionConcurrentTimerTask exceptionTimer = new ExceptionConcurrentTimerTask();
        scheduledExecutorService1.scheduleAtFixedRate(exceptionTimer,1000,1000,TimeUnit.MILLISECONDS);
    }
}

总结：

我们本章节学习了定时任务的基本使用和内部基础原理，TimerTask和Timer并发

曾经也年少
关注
专栏目录
使用Spring Task实现定时任务
qq_59215660的博客
07-27 554
适用于入门spring小白学习
spring boot定时任务(自定义类名字、方法名)线程池
wangrui2009ai的专栏
04-04 709
spring boot定时任务(自定义类名字、方法名)线程池
关于定时任务以及书写规范
weixin_34341117的博客
08-05 398
定时任务： * * * * * 分钟 小时 日 月 周（0-59） （0-23） （1-31） （1-12） （0-7）/n 每隔多久， 表示时间隔断- 表示时间段* 表示重复的时间书写定时任务的若干要领方法：要领1：为定时任务规则加必要的...
【定时任务】——Spring定时任务Scheduled
漫漫长途，终有回转；余味苦涩，终有回甘
01-28 568
定时任务在日常开发过程中非常常见，而且在日常的项目开发中也有多种实现方式，而且做任务调度的框架有很多种，小编最近的感受，如果想真正使用好任务调度还是存在困难的，所以分步学习，逐个击破！在这篇文章小编主要写spring中Scheduled。 spring定时任务设置有两种方式，注解和xml配置。推荐使用注解，在本文章也主要介绍注解方式配置。 注解方式配置定时任务 下面的步骤默认s...
定时器
qq_37025445的博客
06-21 297
本项目采用框架ssm，首先定时器是单独弄了一个module，在这个module下面，有spring配置，有mybatis配置，还有mybatis的分页插件PageHelper的配置，还有关于流程，redis的配置。因为它作为一个单独的模块是能够独立打包运行的。所以所有的配置文件都应该齐全。1.配置文件：applicationContext-task.xml&lt;beans xmlns="http...
furion内置的定时任务使用学习，动态添加定时任务代码
10-24
在本教程中，我们将深入探讨Furion内置的定时任务系统，以及如何动态地添加定时任务。 首先，Furion的定时任务模块允许开发者方便地创建和管理计划任务，无需依赖外部库如Quartz.NET或Hangfire。通过简单的API调用...
(动态多)定时任务源码自动运行调度后台执行
04-10
1、spring 定时任务demo 2、定时任务(xxl-job)（XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。） 3、...
furion内置的定时任务使用学习
10-24
Furion是一款现代化的.NET开发框架，它集成了许多实用的功能，其中之一就是内置的定时任务模块。本篇文章将深入探讨Furion如何帮助开发者轻松实现定时任务，以及相关的使用技巧和注意事项。 首先，Furion的定时任务...
易语言定时任务插件示例
09-07
在IT行业中，定时任务是软件开发中的一个重要组成部分，它允许程序在特定的时间点执行特定的操作。易语言，作为中国本土的编程语言，以其简洁的语法和面向初学者的设计，为开发者提供了实现定时任务的便利。本示例...
《定时执行专家V7.0》一款制作精良、功能强大、毫秒精度、专业级的定时任务执行软件
最新发布
02-22
毫秒精度、功能强大、专业级定时任务执行软件 https://blog.csdn.net/boomworks/article/details/125462611 ▼重要：软件安装目录▼ 1、请将下载的本软件压缩包解压缩到全英文目录（即安装目录），且目录最好不要带...
spring执行定时任务的规则
04-14
Spring中执行定时任务是个很常见的需求，这里是详细的规则说明，有需要的朋友可以参考，跟linux中的crontab规则很相似。
springboot中的异步、邮件、定时任务
起名好难呀！
01-13 201
异步任务 异步任务主要需要两个注解@EnableAsync这个是放在springboot主入口的，用于开启异步任务，@Async这个是放在业务层代码上，用于标注这个是一个异步任务。 业务层代码 package com.zkw.service; import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; @Service public class AsyncSe
spring定时任务详解（@Scheduled注解）
热门推荐
李秀才的博客
07-07 37万+
在springMVC里使用spring的定时任务非常的简单，如下： （一）在xml里加入task的命名空间 xmlns:task="http://www.springframework.org/schema/task" http://www.springframework.org/schema/task http://www.springframework.org/schema/task
Timer定时器的 schedule()方法
fengyeNom1的博客
01-03 1177
timer.schedule(new MyTask(),long time1,long timer2); 今天算是彻底的搞懂了这个曾经让我为之头疼的方法。下面我就重点介绍一下： 第一个参数，是 TimerTask 类，在包：import java.util.TimerTask .使用者要继承该类，并实现public void run() 方法，因为 TimerTask 类 实现了 Runnab...
Java Timer(定时器)
doublepg13的博客
12-14 8085
schedule(TimerTask task , Date time) // 安排在 "指定的时间" 执行 指定的任务。
js中的 setTimeout、setInterval
老五的博客
11-22 493
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 关于JavaScript 中的setTimeout、setInterval具体实现与对比前一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种
SpringTask定时任务的概念和简单使用
weixin_46281472的博客
06-12 1177
目前我本人正在学习SpringFramework的知识，这也是这个专栏的主题。我前面的几篇博文中，简单的认识了一下SpringFramework，记录了SpringFramework的环境搭建，记录了SpringIOC如何加载配置文件，记录了SpringIOC三种Bean对象的实例化方法。还记录了SpringIOC手动装配（注入）的方法之一：set方法注入。还有另外三个不太常用的SpringIOC手动注入的方法。其实目前大部分都使用的是自动注入的方法，手动注入使用的不多。就算是使用手动注入的方法，使用的主流
定时任务 @Scheduled注解
12-03 1427
不同的场景，使用不同的定时任务 1）TimeTask 定时任务，这种定时任务需要触发动作。 参考文档：https://blog.csdn.net/u010502101/article/details/79318380 2）@Scheduled注解，这种定时任务不需要触发动作，项目启动时自动触发 使用方式： 1）在spring的配置文件中，添加task的命名空间 xmln...
spring定时任务(转载)
weixin_30443747的博客
10-09 977
在springMVC里使用spring的定时任务非常的简单，如下： （一）在xml里加入task的命名空间 [html]view plaincopy xmlns:task="http://www.springframework.org/schema/task" http://www.springframework.org/schema/t...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值