手撸XXL-JOB（一）——定时任务的执行

SpringBoot执行定时任务

对于定时任务的执行，SpringBoot提供了三种创建方式：
1）基于注解(@Scheduled)
2）基于接口（SchedulingConfigurer）
3）基于注解设定多线程定时任务

基于Scheduled注解

首先我们创建一个SpringBoot项目，然后引入spring-boot-starter-web依赖，在启动类上添加EnableScheduling注解开启定时任务管理。

package com.yang.demo1;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class ScheduledDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(ScheduledDemoApplication.class, args);
    }
}

然后我们创建一个定时任务，并使用Scheduled注解

package com.yang.demo1;

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

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class DemoTask {
    @Scheduled(cron = "0/5 * * * * ?") // 每5秒执行一次
    public void execute() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("hello world: " + df.format(new Date()));
    }
}

启动项目，执行结果如下所示，每隔5秒，便会执行一次定时任务。
image.png
Scheduled注解类的源码如下：

package org.springframework.scheduling.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {
    String CRON_DISABLED = "-";
 
    String cron() default "";
 
    String zone() default "";
 
    long fixedDelay() default -1L;
 
    String fixedDelayString() default "";
 
    long fixedRate() default -1L;
 
    String fixedRateString() default "";
 
    long initialDelay() default -1L;
 
    String initialDelayString() default "";
}

除了刚才代码中使用到的cron参数，我们还可以使用fixedDelay和fixedRate等参数。fixedDelay和fixedRate很相似，但又略有不同，其中fixedDelay表示在某次任务执行完毕后，间隔fixedDelay的时间再执行，而fixedRate表示在某次任务执行开始后，间隔fixedRate的时间再执行。
我们对这两个参数，添加对应的测试方法：

  @Scheduled(fixedDelay = 5000)
    public void executeFixedDelay() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("executeFixedDelay开始执行了==========" + df.format(new Date()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Scheduled(fixedRate = 5000)
    public void executeFixedRate() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("executeFixedRate开始执行了==========" + df.format(new Date()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

启动项目，执行结果如下。我们可以看到，executeFixedDelay在任务执行完毕后，间隔5秒才执行下一个任务，也就是说，两个任务之间间隔7秒，而executeFixedRate在任务执行开始后，间隔5秒执行下一个任务，也就是两个任务之间间隔5秒。综上所示，fixedDelay和fixedRate之间的区别，其实就在于计算两个任务执行间隔时，需不需要考虑任务的执行时长。
image.png

基于SchedulingConfigurer接口

首先我们在数据库中创建t_cron表，并添加数据：

DROP TABLE IF EXISTS t_cron;
CREATE TABLE t_cron  (
  cron_id VARCHAR(30) NOT NULL PRIMARY KEY,
  cron VARCHAR(30) NOT NULL  
);
 
INSERT INTO t_cron VALUES ('1', '0/5 * * * * ?');

然后修改pom.xml，加上数据库的相关依赖：

  <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>

修改配置文件：

spring:
  datasource:
    username: root
    password: 3fa4d180
    url: jdbc:mysql://localhost:3306/test01?useSSL=false&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

创建对应的mapper：

package com.yang.demo1.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface CronMapper {
    @Select("select cron from t_cron limit 1")
    String getCron();
}

然后，我们编写定时任务，通过读取我们在数据库设置好的执行周期，来执行定时任务，代码如下：

package com.yang.demo1;

import com.yang.demo1.mapper.CronMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;

import java.time.LocalDateTime;

@Configuration
@EnableScheduling
public class DynamicScheduleConfigurer implements SchedulingConfigurer {
    @Autowired
    private CronMapper cronMapper;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
                () -> execute(),
                triggerContext -> {
                    String cron = cronMapper.getCron();
                    if (StringUtils.isEmpty(cron)) {
                        throw new RuntimeException("cron 格式有误");
                    }
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );
    }

    private void execute() {
        System.out.println("hello world:" + new Date());
    }
}

执行结果如下所示，一开始的cron是每5秒执行一次，后来我们修改cron，改为10秒执行一次，此时任务的执行频率，也随之我们数据库的修改动态地进行了调整。
image.png

EnableAsync注解

对于Scheduled，默认为单线程，当开启多个任务时，任务地执行实际会受到上一个任务执行时间地影响，所以需要使用Async注解，通过该注解开启多线程使任务之间不会相互影响。

ScheduledExecutorService执行定时任务

SpringBoot执行定时任务很简单，但是如果我们不使用SpringBoot，又该如何启动定时任务？这个时候，我们就可以使用ScheduledExecutorService接口，这个接口用于在一些预定义的延迟之后运行任务或定期运行任务。我们可以通过Executors类的工厂方法实例化ScheduledExecutorService，如下：

        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

在ScheduledExecutorService接口中，有三个主要方法：
1）schedule：允许在指定的延迟后执行一次任务。
2）scheduleAtFixedRate：允许在指定的初始延迟后执行任务，然后以一定的周期重复执行，其中period参数用于指定两个任务的开始时间之间的间隔时间，因此任务执行的频率是固定的。
3）scheduleWithFixedDelay：类似于scheduleAtFixedRate，它也重复执行给定的任务，单period参数用于指定前一个任务的结束和下一个任务的开始之间的间隔时间，也就是指定下一个任务延时多久后才执行，执行频率可能会有所不同，具体取决于执行任务给定任务所需的时间。

schedule方法
package com.yang.demo2;

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

public class ScheduledExecutorServiceMain {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.schedule(() -> {
            System.out.println("Hello World:" + new Date());
        }, 1, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果如下：在延迟一秒后，开始执行任务，且只执行一次。
image.png

scheduleAtFixRate

当我们需要在固定延迟后，定期执行任务时，可以使用scheduleAtFixedRate方法，如下所示，每隔2秒执行相同的任务

public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Hello World:" + new Date());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

结果如下：
image.png
如果任务执行时间比间隔时间长，那么scheduledExecutorService将等待当前任务执行完毕后再开始执行下一个任务，我们修改代码如下：

 ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(4);
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Hello World:" + new Date());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

结果如下，每隔3秒执行一次任务
image.png

scheduleWithFixedDelay方法

如果任务之间必须具有固定长度的延迟，那么可以使用scheduleWithFixedDelay方法。

  public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(4);
        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            System.out.println("Hello World:" + new Date());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

在上述代码中，任务执行时长需要1秒，然后设置的间隔时间为2秒，因此，我们可以看到，每隔任务之间，间隔3秒执行一次
image.png

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/625689.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

c#多态性的应用

c#多态性的应用

设计一个电脑游戏&#xff0c;游戏中有猪、牛、兔子、青蛙、鸭子等动物&#xff0c;这些动 物都继承于Vertebrata 类&#xff08;脊椎动物类&#xff09;&#xff0c;Vertebrata类有一个抽象方法Display()&#xff0c;每个动 物都从Vertebrata 类那里继承并重写了Display()方法…
阅读更多...
Naive RAG 、Advanced RAG 和 Modular RAG 简介

Naive RAG 、Advanced RAG 和 Modular RAG 简介

简介&#xff1a; RAG&#xff08;Retrieval-Augmented Generation&#xff09;系统是一种结合了检索&#xff08;Retrieval&#xff09;和生成&#xff08;Generation&#xff09;的机制&#xff0c;用于提高大型语言模型&#xff08;LLMs&#xff09;在特定任务上的表现。随…
阅读更多...
【Vue】Vue指令与生命周期以及组件化编码

【Vue】Vue指令与生命周期以及组件化编码

目录 常用内置指令v-text与v-htmlv-text : 更新元素的 textContentv-html : 更新元素的 innerHTML注意&#xff1a;v-html有安全性问题&#xff01;&#xff01;&#xff01;&#xff01; v-once与v-prev-oncev-pre ref与v-cloakrefv-cloak 自定义指令案例定义语法配置对象中常…
阅读更多...
Visual Studio Community : The prerelease has expired

Visual Studio Community : The prerelease has expired

最近使用旧版的离线安装包安装社区版Visual Studio2022&#xff08;Visual Studio Community 2022&#xff09;&#xff0c;安装完成后显示&#xff1a;The prerelease has expired。使用自己的微软账号登录还是一样的情况&#xff0c;只能强制退出。经过摸索后发现了一个解决方…
阅读更多...
选择法（数值排序）（C语言）

选择法（数值排序）（C语言）

一、运行结果&#xff1b; 二、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>//声明排序函数sort; void sort(int a[], int n);int main() {//初始化变量值&#xff1b;int i, a[10];//填充数组&#xff1b;printf("请输入10个整数\n&…
阅读更多...
OSI 网络互联参考模型的思考与总结

OSI 网络互联参考模型的思考与总结

前言&#xff1a; 最近一个项目用到了SmartLink配网&#xff0c; 涉及到了UDP的广播和组播&#xff0c;所以就想着回顾总结了下ISO参考模型的相关知识。 OSI&#xff08;Open System Interconnect&#xff09;&#xff0c;即开放式系统互连。 一般都叫OSI参考模型&#xff0c;…
阅读更多...
【Linux】自动化编译工具——make/makefile(超细图例详解！！)

【Linux】自动化编译工具——make/makefile(超细图例详解！！)

目录 一、前言 二、make / Makefile背景介绍 &#x1f95d;Makefile是干什么的&#xff1f; &#x1f347;make又是什么&#xff1f; 三、demo实现【见见猪跑&#x1f416;】 四、依赖关系与依赖方法 1、概念理清 2、感性理解【父与子&#x1f468;】 3、深层理解【程序…
阅读更多...
30-10y国债利差反转的必要条件

30-10y国债利差反转的必要条件

国君宏观表示&#xff0c;30-10y期限利差定价本质上是私人部门主动加杠杆的预期&#xff0c;央行购债与资本市场的正向反馈是可以期待的一种场景&#xff0c;而企业部门的被动加杠杆须以可持续的需求动能与盈利预期作为前提。 要点&#xff1a; 期限利差的本质&#xff1a;对长…
阅读更多...
C++：编程领域的全能王者

C++：编程领域的全能王者

在编程语言的海洋中&#xff0c;C以其全面而强大的功能&#xff0c;犹如一位全能王者&#xff0c;屹立不倒。它不仅在科技领域有着广泛的应用&#xff0c;更在推动社会进步、促进人类创新方面发挥着至关重要的作用。 一、C&#xff1a;编程界的璀璨明星 C自诞生以来&#xff…
阅读更多...
时间序列预测模型实战案例(三)(LSTM)(Python)(深度学习)时间序列预测(包括运行代码以及代码讲解)

时间序列预测模型实战案例(三)(LSTM)(Python)(深度学习)时间序列预测(包括运行代码以及代码讲解)

目录 引言 LSTM的预测效果图 LSTM机制 了解LSTM的结构 忘记门 输入门 输出门 LSTM的变体 只有忘记门的LSTM单元 独立循环(IndRNN)单元 双向RNN结构(LSTM) 运行代码 代码讲解 引言 LSTM&#xff08;Long Short-Term Memory&#xff09;是一种常用的循环神经网络&a…
阅读更多...
数据库的存储过程、函数与触发器

数据库的存储过程、函数与触发器

使用下面的场景来引入 1.创建表 CREATE DATABASE staff; USE staff; CREATE TABLE employee(id INT NOT NULL AUTO_INCREMENT,userName VARCHAR(255),birthDate DATE,idCard VARCHAR(255),loginName VARCHAR(255),PASSWORD VARCHAR(255),mobile VARCHAR(255),email VARCHAR(2…
阅读更多...
Python爬虫——如何使用urllib的HTTP基本库

Python爬虫——如何使用urllib的HTTP基本库

怎样通过 urllib库 发送 HTTP 请求&#xff1f; urllib库主要由四个模块组成: urllib.request 打开和读取 URLurllib.error 包含 urllib.request 抛出的异常urllib.parse 用于解析 URLurllib.robotparser 用于解析 robots.txt 文件 1. 使用urllib.parse解析URL 使用urlparse(…
阅读更多...
C++：编程世界的永恒之石

C++：编程世界的永恒之石

在编程的广袤领域中&#xff0c;C犹如一块永恒的基石&#xff0c;历经岁月的洗礼&#xff0c;依旧坚固而璀璨。它的深厚底蕴、强大功能和广泛的应用领域&#xff0c;使其成为无数程序员心中的信仰与追求。 一、C&#xff1a;历史与传承的交汇点 C的历史可追溯到上世纪80年代&…
阅读更多...
Spring自定义配置属性类

Spring自定义配置属性类

以一个minio的配置类为例 首先&#xff0c;由于minio模块被很多微服务需要&#xff0c;因此封装了一个starter&#xff0c;当背的微服务需要的时候就进行引入。 以下是starter模块的结构图 一、spring.factories文件 org.springframework.boot.autoconfigure.EnableAutoConf…
阅读更多...
2.1.2 事件驱动reactor的原理与实现

2.1.2 事件驱动reactor的原理与实现

LINUX 精通 2 day14 20240513 day15 20240514 算法刷题&#xff1a;2维前缀和&#xff0c;一二维差分 耗时 135min 习题课 4h 课程补20240425 耗时&#xff1a;4h 课程链接地址 回顾 怎么学0voice课网络io——一请求一线程&#xff0c;一个client一个连接再accpet分配io f…
阅读更多...
每日两题 / 437. 路径总和 III 105. 从前序与中序遍历序列构造二叉树（LeetCode热题100）

每日两题 / 437. 路径总和 III 105. 从前序与中序遍历序列构造二叉树（LeetCode热题100）

437. 路径总和 III - 力扣&#xff08;LeetCode&#xff09; 前序遍历时&#xff0c;维护当前路径&#xff08;根节点开始&#xff09;的路径和&#xff0c;同时记录路径上每个节点的路径和 假设当前路径和为cur&#xff0c;那么ans 路径和(cur - target)的出现次数 /*** D…
阅读更多...
C语言：指针（3）

C语言：指针（3）

1. 字符指针变量 在指针的类型中我们知道有⼀种指针类型为字符指针 char* ; 本质是把字符串 hello bit. ⾸字符的地址放到了pstr中。上⾯代码的意思是把⼀个常量字符串的⾸字符 h 的地址存放到指针变量 pstr 中。 2. 数组指针变量 2.1 数组指针变量是什么&#xff1f; 答案…
阅读更多...
2024年高考倒计时精品网页

2024年高考倒计时精品网页

2024年高考倒计时精品网页 前言效果图部分代码领取源码下期更新预报 前言 随着季风轻轻掠过&#xff0c;岁月如梭&#xff0c;再次迎来了这个属于青春与梦想交汇的时刻——高考。这是一场知识的较量&#xff0c;更是一次意志的考验。在这最后的冲刺阶段&#xff0c;每一刻都显…
阅读更多...
注意力机制篇 | YOLOv8改进之在C2f模块引入反向残差注意力模块iRMB | CVPR 2023

注意力机制篇 | YOLOv8改进之在C2f模块引入反向残差注意力模块iRMB | CVPR 2023

前言：Hello大家好，我是小哥谈。反向残差注意力模块iRMB是一种用于图像分类和目标检测的深度学习模块。它结合了反向残差和注意力机制的优点，能够有效地提高模型的性能。在iRMB中，反向残差指的是将原始的残差块进行反转，即将卷积操作和批量归一化操作放在了后面。这样做的好…
阅读更多...
第 5 篇 : 多节点Netty服务端(可扩展)

第 5 篇 : 多节点Netty服务端(可扩展)

说明 前面消息互发以及广播都是单机就可以完成测试, 但实际场景中客户端的连接数量很大, 那就需要有一定数量的服务端去支撑, 所以准备虚拟机测试。 1. 虚拟机准备 1.1 准备1个1核1G的虚拟机(160), 配置java环境, 安装redis和minio 1.2 准备6个1核1G的空虚拟机(161到166), …
阅读更多...
最新文章

Copyright @ 2022~2023