定时任务的实现

已于 2024-08-26 15:43:47 修改
阅读量660 收藏 15
点赞数 17
文章标签： 开发语言 java
于 2024-08-26 15:42:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64272546/article/details/141563119
版权

1.1什么是任务

我们可以思考一下什么是任务

  • 平台需要每天晚上8点发放一批优惠券

  • 系统需要在VIP到期前1天进行提醒

  • 系统需要在每天结算前一天的财务数据

  • 经理要我们每天5点提交代码

这些就是任务，需要定时解决的任务，在代码中如何去解决就是这篇文章存在的目的

1.2任务调度

在Java中，实现定时任务有多种方式，下面是我了解到的一些方法：

1. 使用java.util.Timer和java.util.TimerTask

Timer类是一个工具，用于安排一个线程来执行在将来某一特定时间执行的任务，或者定期地执行。TimerTask是一个实现了Runnable接口的抽象类，需要实现run方法。

import java.util.Timer;  
import java.util.TimerTask;  
  
public class TimerExample {  
    public static void main(String[] args) {  
        Timer timer = new Timer();  
  
        TimerTask task = new TimerTask() {  
            @Override  
            public void run() {  
                System.out.println("简单任务 " + System.currentTimeMillis());  
            }  
        };  
  
        // 安排任务在指定延迟后执行  
        timer.schedule(task, 1000); // 延迟1000毫秒执行  
  
        // 或者安排任务定期执行  
         timer.scheduleAtFixedRate(task, 0, 2000); 
        // 延迟0毫秒后开始，每2000毫秒执行一次  
    }  
}

2. 使用ScheduledExecutorService
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
  
public class ScheduledExecutorServiceExample {  
    public static void main(String[] args) {  
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);  
  
        Runnable task = () -> System.out.println("简单任务 " + System.currentTimeMillis());  
  
        // 延迟执行  
        scheduler.schedule(task, 1, TimeUnit.SECONDS);  
  
        // 定期执行  
        scheduler.scheduleAtFixedRate(task, 0, 2, TimeUnit.SECONDS); 
// 延迟0秒后开始，之后每2秒执行一次  
    }  
}
 

3. 使用Spring @Scheduled注解
 

如果你的应用是基于Spring框架的，那么可以使用@Scheduled注解非常方便地实现定时任务。这是我在不使用xxl_job常用的定时任务代码：（Spring配置类上添加@EnableScheduling注解，以启用Spring的定时任务支持）
 

在方法上加一个注解就行了，当然这是毫秒单位
 

 @Scheduled(fixedRate = 5000) 
 

常用的属性配置：
 

  • fixedRate：以固定的频率执行任务，单位是毫秒。例如，fixedRate = 5000 表示任务每隔5秒执行一次。
  • fixedDelay：在上一次任务执行完成后，延迟指定的时间再执行下一次任务，单位也是毫秒。
  • cron：通过 cron 表达式来定义任务的执行计划。cron 表达式提供了非常灵活的方式来定义任务的执行时间。
  • initialDelay：在首次执行任务之前延迟的时间，单位也是毫秒。
 

还有用cron表达式一样的效果，但是这需要学习一下。
 

@Scheduled(cron = "0 0/5 * * * ?")  
public void doSomethingWithCron() {  
    // 这个方法会在每小时的每5分钟执行一次  
    System.out.println("简单任务");  
}
 

至于任务的执行，不得不谈到异步：
 

默认情况下，@Scheduled注解的方法会在调用它们的同一个线程中同步执行。如果你希望这些方法异步执行，以避免阻塞主线程或调度线程，需要将@Async注解与@Scheduled一起使用（但请注意，这可能需要额外的配置来启用Spring的异步支持）。
 

 

1.3分布式任务调度
 

万物皆可分布式，分布式的好处直接上百度：
 

  1.  
    高可用：单机版的定式任务调度只能在一台机器上运行，如果程序或者系统出现异常就会导致功能不可用。
     
  2.  
    防止重复执行: 在单机模式下，定时任务是没什么问题的。但当我们部署了多台服务，同时又每台服务又有定时任务时，若不进行合理的控制在同一时间，只有一个定时任务启动执行，这时，定时执行的结果就可能存在混乱和错误了
     
  3.  
    单机处理极限：原本1分钟内需要处理1万个订单，但是现在需要1分钟内处理10万个订单；原来一个统计需要1小时，现在业务方需要10分钟就统计出来。你也许会说，你也可以多线程、单机多进程处理。的确，多线程并行处理可以提高单位时间的处理效率，但是单机能力毕竟有限（主要是CPU、内存和磁盘），始终会有单机处理不过来的情况。
     
 

1.关于XXL_JOB：
 

XXL-Job：是大众点评的分布式任务调度平台，是一个轻量级分布式任务调度平台, 其核心设计目标是开发迅速、学习简单、轻量级、易扩展
 

大众点评目前已接入XXL-JOB，该系统在内部已调度约100万次，表现优异。
 

目前已有多家公司接入xxl-job，包括比较知名的大众点评，京东，优信二手车，360金融 (360)，联想集团 (联想)，易信 (网易)等等
 

官网地址： 分布式任务调度平台XXL-JOB
 

源码下载地址:
 

GitHub - xuxueli/xxl-job: A distributed task scheduling framework.（分布式任务调度平台XXL-JOB）
 

xxl-job: 一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。
 

2.初始化调度数据库
 

请下载项目源码并解压，获取 “调度数据库初始化SQL脚本” 并执行即可，会下载一个springboot项目。
 

“调度数据库初始化SQL脚本” 位置为: /xxl-job/doc/db/tables_xxl_job.sql
 

3.调度中心配置
 

修改xxl-job-admin项目的配置文件application.properties,把数据库账号密码配置上：
 

### web
server.port=8080
server.servlet.context-path=/xxl-job-admin

### actuator
management.server.servlet.context-path=/actuator
management.health.mail.enabled=false

### resources
spring.mvc.servlet.load-on-startup=0
spring.mvc.static-path-pattern=/static/**
spring.resources.static-locations=classpath:/static/

### freemarker
spring.freemarker.templateLoaderPath=classpath:/templates/
spring.freemarker.suffix=.ftl
spring.freemarker.charset=UTF-8
spring.freemarker.request-context-attribute=request
spring.freemarker.settings.number_format=0.##########

### mybatis
mybatis.mapper-locations=classpath:/mybatis-mapper/*Mapper.xml
#mybatis.type-aliases-package=com.xxl.job.admin.core.model

### xxl-job, datasource
spring.datasource.url=jdbc:mysql://192.168.202.200:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=WolfCode_2017
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

### datasource-pool
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.auto-commit=true
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.pool-name=HikariCP
spring.datasource.hikari.max-lifetime=900000
spring.datasource.hikari.connection-timeout=10000
spring.datasource.hikari.connection-test-query=SELECT 1
spring.datasource.hikari.validation-timeout=1000

### xxl-job, email
spring.mail.host=smtp.qq.com
spring.mail.port=25
spring.mail.username=xxx@qq.com
spring.mail.from=xxx@qq.com
spring.mail.password=xxx
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true
spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory

### xxl-job, access token
xxl.job.accessToken=default_token

### xxl-job, i18n (default is zh_CN, and you can choose "zh_CN", "zh_TC" and "en")
xxl.job.i18n=zh_CN

## xxl-job, triggerpool max size
xxl.job.triggerpool.fast.max=200
xxl.job.triggerpool.slow.max=100

### xxl-job, log retention days
xxl.job.logretentiondays=30
 

 

4.部署项目
 

运行XxlJobAdminApplication程序即可.
 

调度中心访问地址: http://localhost:8080/xxl-job-admin
 

默认登录账号 “admin/123456”, 登录后运行界面如下图所示。
 

5.启动
 

添加Maven依赖
 

创建SpringBoot项目并且添加如下依赖:
 

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.3.1</version>
</dependency>
 

 执行器配置
 

在配置文件中添加如下配置:
 

### 调度中心部署根地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin
### 执行器通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=default_token
### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
xxl.job.executor.appname=xxl-job-executor-sample
### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
xxl.job.executor.address=
### 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
xxl.job.executor.ip=127.0.0.1
### 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
xxl.job.executor.port=9999
### 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
### 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
xxl.job.executor.logretentiondays=30
 

添加执行器配置
 

创建XxlJobConfig配置对象:
 

@Configuration
public class XxlJobConfig {
    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;
    @Value("${xxl.job.accessToken}")
    private String accessToken;
    @Value("${xxl.job.executor.appname}")
    private String appname;
    @Value("${xxl.job.executor.address}")
    private String address;
    @Value("${xxl.job.executor.ip}")
    private String ip;
    @Value("${xxl.job.executor.port}")
    private int port;
    @Value("${xxl.job.executor.logpath}")
    private String logPath;
    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;
​
    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
        return xxlJobSpringExecutor;
    }
}
 

处理方法上贴上@XxlJob注解
 

@Component
public class SimpleXxlJob {
    @XxlJob("demoJobHandler")
    public void demoJobHandler() throws Exception {
        System.out.println("执行定时任务,执行时间:"+new Date());
    }
}
 

6.可视化操作：
 

2.5 运行HelloWorld程序
 

2.5.1 任务配置&触发执行
 

任务管理中新增任务,配置内容如下:
 

 

 

接着启动定时调度任务
 

2.5.2 查看日志
 

在调度中心的调度日志中就可以看到，任务的执行结果.
 

管控台也可以看到任务的执行信息.
 

一般常用两个模式：上面的就是bean模式
 

BEAN模式和GLUE模式
 

GLUE模式就是在平台上写代码接入项目中实现它在执行器项目中运行，可使用@Resource/@Autowire注入执行器里中的其他服务。我就不演示了。
 

 

写在后头
 

想学习用在自己的项目中的小伙伴们，我在这略做提示：
 

数据备份：数据清洗与整理：报表生成：系统维护：批量数据处理：定时清理缓存：定时发送通知：爬虫任务：这些场景比较好体现定时任务的作用。
 

定时任务的使用场景对于我来说，也只是在之前的个人开发有学习使用，这么来说可能使用的深度不够，所以文章的水平也有限，公司里的定时任务需求我也还没写过，对定时任务的骚操作可能也不够了解，海涵。

                

        

        

    




    

      

        

            

              
                
                  高危型
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    17
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    15
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
SpringBoot基于数据库的定时任务实现

				
			

			

				

					u011134780的博客
				

				

					12-28
					
					7572
					
				

			

		

		

			
				
在我们平时开发的项目中，定时任务基本属于必不可少的功能，那大家都是怎么做的呢？但我知道的大多都是静态定时任务实现。

基于注解来创建定时任务非常简单，只需几行代码便可完成。实现如下：


@Configuration
@EnableScheduling
public class SimpleScheduleTask {

    //10秒钟执行一次
    @Scheduled(cron = "...

			
		

	



                

              
                



	

		

			

				
					
spring定时任务实现

				
			

			

				

					04-12
				

			

		

		

			
				
Spring框架提供了多种方式来实现定时任务，这使得开发者可以在不同场景下选择最适合的方案。本文主要探讨了Spring中实现定时任务的三种主要方法：Java的`java.util.Timer`、Quartz库以及Spring自身的Task调度器。  ...

			
		

	



                


  
              

                


	

		

			

				
					
Java -- 定时任务实现方式

				
			

			

				

					MinggeQingchun的博客
				

				

					08-25
					
					3万+
					
				

			

		

		

			
				
定义Job有两种方式，@Servicetry {}}}第二种是继承，重写方法，这种方式可以接受JobDetail传递的参数@Overridetry {}// 获取参数System.out.println("参数：" + date);}}这样就把JobDetail和我们之前定义的QuartzJob关联起来了。...

			
		

	





	

		

			

				
					
JAVA 定时任务实现方式

				
			

			

				

					qq_41482600的博客
				

				

					07-29
					
					7156
					
				

			

		

		

			
				
定时任务


			
		

	



		

			
		



	

		

			

				
					
Java实现定时任务

				
			

			

				

					dreaming9420的博客
				

				

					04-08
					
					2万+
					
				

			

		

		

			
				
文章目录1 使用java.util.Timer2 使用ScheduledExecutorService3 使用Spring Task
1 使用java.util.Timer
这种方式的定时任务主要用到两个类，Timer 和 TimerTask，使用起来比较简单。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。 TimerTask是一个抽象类，new的时候实现自己的 run 方法，然后将其丢给 Timer 去执行即可。
代码示例：
import java.time.LocalDateTi

			
		

	





	

		

			

				
					
深入剖析Netty之定时任务实现

				
			

			

				

					
				

				

					01-30
					
					1762
					
				

			

		

		

			
				
Netty的定时任务实现

			
		

	





	

		

			

				
					
Java 定时任务实现原理详解

					
热门推荐

				
			

			

				

					u013332124的专栏
				

				

					03-18
					
					5万+
					
				

			

		

		

			
				
在jdk自带的库中,有两种技术可以实现定时任务。一种是使用Timer,另外一个则是ScheduledThreadPoolExecutor。下面为大家分析一下这两个技术的底层实现原理以及各自的优缺点。



一、Timer



1. Timer的使用



class MyTask extends TimerTask{
    @Override
    public void run() {
 ...

			
		

	





	

		

			

				
					
RabbitMQ基于Java的定时任务实现

				
			

			

				

					t0m的专栏
				

				

					08-30
					
					1960
					
				

			

		

		

			
				
RabbitMQ的定时任务实现主要原理是借助rabbitmq的消息过期机制，发送消息时可以指定一个expiration(单位毫秒)，当一个消息在一个队列内过期时，在默认情况下会drop丢弃掉(此处有个条件，就是该消息必须位于队首，也就是即将被消费时才会判断是否过期，也就是说不在队首的消息即使expiration到期也无法丢弃到死信队列)。如果队列配置了死信队列exchange和routing ke...

			
		

	





	

		

			

				
					
超级简单！Spring中四种霸气定时任务实现方式

				
			

			

				

					八戒的博客
				

				

					11-03
					
					1540
					
				

			

		

		

			
				
当涉及到定时任务的实现，提供了多种强大的选项，以适应各种需求。在这篇文章中，我们将介绍Spring中的几种不同方式来实现定时任务，包括使用@Scheduled注解、接口、和集成框架。

			
		

	





	

		

			

				
					
C语言实现定时任务

				
			

			

				

					佳佳鸽的博客
				

				

					02-25
					
					4314
					
				

			

		

		

			
				
例:设置定时任务,每周周X的X时X分自动重启系统
思路:将设置好的重启时间保存到本地配置文件中,设置定时器定时一分钟,每一分钟信号触发一次事件,事件函数中获取配置文件信息与当前系统时间信息,将两个时间进行时间差计算,符合条件的自动重启系统.
//创建定时器函数(通过信号触发事件timer_task函数启动)
int create_timer()
{
    struct sigevent evp;  
    int ret = 0;

    memset(&evp, 0, sizeof(stru

			
		

	





	

		

			

				
					
Django实现定时任务

				
			

			

				

					LoadingCreate的博客
				

				

					06-19
					
					1237
					
				

			

		

		

			
				
实现一个定时任务需要使用Django中的Celery和Django-crontab。Celery是一个分布式任务队列，可以让我们异步执行耗时的任务，而Django-crontab是一个基于Celery的Django定时任务调度库。现在，每个小时的0分钟时，Celery会自动执行write_article任务，你可以在任务函数中编写你的写文章逻辑，例如创建一个新的Article模型并将其保存到数据库中。

			
		

	





	

		

			

				
					
SpringBoot定时任务实现Oracle和mysql数据同步

				
			

			

				

					12-21
				

			

		

		

			
				
Spring Boot作为Java领域的一个热门微服务框架，提供了强大的定时任务功能，能够帮助我们实现不同数据库间的数据同步，比如Oracle到MySQL。本篇文章将详细讲解如何利用Spring Boot的定时任务特性，结合Java的相关...

			
		

	





	

		

			

				
					
Spring+Quartz配置定时任务实现代码

				
			

			

				

					08-19
				

			

		

		

			
				
Spring+Quartz配置定时任务实现代码  Spring和Quartz是两个非常流行的开源框架，Spring是一个基于Java的企业级应用程序开发框架，而Quartz是一个功能强大且灵活的开源调度框架。两者相结合，可以实现灵活可配置的...

			
		

	





	

		

			

				
					
java中 spring 定时任务 实现代码

				
			

			

				

					09-05
				

			

		

		

			
				
本篇文章将详细介绍如何在Spring中实现定时任务，并给出具体的代码示例。  首先，我们需要一个执行定时任务的类，例如`TaskJob`。这个类通常包含一个或多个方法，这些方法将在定时任务触发时被调用。在给定的代码中...

			
		

	





	

		

			

				
					
Spring定时任务实现与配置（一）

				
			

			

				

					08-30
				

			

		

		

			
				
Spring定时任务实现与配置（一）  本文主要介绍了Spring定时任务的实现与配置，涵盖了基本概念、依赖管理、配置文件设置、Quartz配置、Job配置等方面的知识点。  Spring定时任务的基本概念  在Spring中，定时任务是...

			
		

	





	

		

			

				
					
第2章 C语言基础知识

				
			

			

				

					m0_70617423的博客
				

				

					08-14
					
					2718
					
				

			

		

		

			
				
C语言

			
		

	





	

		

			

				
					
python爬虫爬取某图书网页实例

				
			

			

				

					2301_77698138的博客
				

				

					08-14
					
					3897
					
				

			

		

		

			
				
下面是通过requests库来对ajax页面进行爬取的案例，与正常页面不同，这里我们获取url的方式也会不同，这里我们通过爬取一个简单的ajax小说页面来为大家讲解。循环遍历URL（这里为大家提供具体url的获取方法，并循环了1至9页的数据为大家做案例），并发送了带有随机User-Agent的GET请求。设置代码来保存图片到以文章名命名的文件中，并将作者、文章名和简介信息写入到"./biquge.txt"文件中。首先进入网页，点击F12打开自定义与控制工具，点击fecth/XHR，此时显示部分为空白。

			
		

	





	

		

			

				
					
开发多线程程序时，需要注意那些问题

					
最新发布

				
			

			

				

					OO_SEN的博客
				

				

					08-23
					
					554
					
				

			

		

		

			
				
线程安全
竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。
死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。
活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。
优先级反转（P

			
		

	





	

		

			

				
					
Yolov8：模型部署到安卓端

				
			

			

				

					m0_70694811的博客
				

				

					08-21
					
					792
					
				

			

		

		

			
				
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。

			
		

	





	

		

			

				
					
java定时任务实现方式

				
			

			

				

					05-05
				

			

		

		

			
				
Java中有多种实现定时任务的方式，以下是几种常见的实现方式：

1. Timer类：Timer类是Java提供的一个定时器工具类，可以用它来实现简单的定时任务，具体实现方法可以参考以下代码：

```
Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        // 定时任务执行的代码
    }
}, delay, period);
```

其中，delay表示延迟多少毫秒后开始执行定时任务，period表示定时任务执行的周期，单位是毫秒。

2. ScheduledExecutorService接口：ScheduledExecutorService接口是Java提供的一个定时任务调度器，通过它可以更加灵活地实现定时任务，具体实现方法可以参考以下代码：

```
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
executor.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        // 定时任务执行的代码
    }
}, initialDelay, period, TimeUnit.MILLISECONDS);
```

其中，initialDelay表示延迟多少毫秒后开始执行定时任务，period表示定时任务执行的周期，TimeUnit.MILLISECONDS表示周期的单位是毫秒。

3. Quartz框架：Quartz是一个开源的作业调度框架，可以用它来实现复杂的定时任务调度，具体实现方法可以参考以下代码：

```
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler scheduler = sf.getScheduler();
JobDetail job = newJob(MyJob.class)
    .withIdentity("job1", "group1")
    .build();
Trigger trigger = newTrigger()
    .withIdentity("trigger1", "group1")
    .startNow()
    .withSchedule(simpleSchedule()
        .withIntervalInSeconds(10)
        .repeatForever())
    .build();
scheduler.scheduleJob(job, trigger);
scheduler.start();
```

其中，MyJob是需要执行的定时任务类，simpleSchedule()方法表示定时任务的执行规则是简单的重复执行，withIntervalInSeconds(10)表示每隔10秒执行一次定时任务。

以上是几种常见的Java定时任务实现方式，具体选择哪种方式可以根据实际需求来进行选择。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值