GVKun编程网logo

Java项目实现定时任务的三种方法（java项目实现定时任务的三种方法是什么）

3

本文将介绍Java项目实现定时任务的三种方法的详细情况，特别是关于java项目实现定时任务的三种方法是什么的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一

本文将介绍Java项目实现定时任务的三种方法的详细情况，特别是关于java项目实现定时任务的三种方法是什么的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Java 定时任务系列（2）-Spring 定时任务的几种实现、java 定时器，固定某个时间执行（Spring+Quartz实现定时任务的配置方法）、Java 实现定时任务的三种方法、JavaScript函数定时器：实现定时任务的实用工具的知识。

本文目录一览：

Java项目实现定时任务的三种方法（java项目实现定时任务的三种方法是什么）

Java项目实现定时任务的三种方法（java项目实现定时任务的三种方法是什么）

1 使用java.util.Timer

这种方式的定时任务主要用到两个类，Timer 和 TimerTask，使用起来比较简单。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。 TimerTask是一个抽象类，new的时候实现自己的 run 方法，然后将其丢给 Timer 去执行即可。

代码示例：

import java.time.LocalDateTime;
import java.util.Timer;
import java.util.TimerTask;

public class Schedule {
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
            }
        };
        // 在指定延迟0毫秒后开始，随后地执行以2000毫秒间隔执行timerTask 
        new Timer().schedule(timerTask, 0L, 2000L);
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }
}

缺点：

  • Timer 的背后只有一个线程，不管有多少个任务，都只有一个工作线程串行执行，效率低下
  • 受限于单线程，如果第一个任务逻辑上死循环了，后续的任务一个都得不到执行
  • 依然是由于单线程，任一任务抛出异常后，整个 Timer 就会结束，后续任务全部都无法执行

2 使用ScheduledExecutorService

ScheduledExecutorService 即是 Timer 的替代者，JDK 1.5 并发包引入，是基于线程池设计的定时任务类。每个调度任务都会分配到线程池中的某一个线程去执行，任务就是并发调度执行的，任务之间互不影响。

Java 5.0引入了java.util.concurrent包，其中的并发实用程序之一是ScheduledThreadPoolExecutor ，它是一个线程池，用于以给定的速率或延迟重复执行任务。它实际上是Timer/TimerTask组合的更通用替代品，因为它允许多个服务线程，接受各种时间单位，并且不需要子类TimerTask （只需实现Runnable）。使用一个线程配置ScheduledThreadPoolExecutor使其等效于Timer 。

代码示例：

import java.time.LocalDateTime;
import java.util.concurrent.*;

public class Schedule {
    public static void main(String[] args) {
        // 创建一个ScheduledThreadPoolExecutor线程池，核心线程数为5
        ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5);
        // 创建Runnable打印当前线程和当前时间
        Runnable r = () -> System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
        /**
         * schedule：只执行一次调度
         * scheduleAtFixedRate：一开始就计算间隔时间，如果任务超过间隔时间，那么就直接开始下一个任务
         * scheduleWithFixedDelay：任务无论执行多久，都要等待上一轮任务完成之后再间隔指定时间，然后才开始下一个任务
         */
         // 在指定1秒延迟后执行r,之后每两秒执行一次
        scheduledExecutorService.scheduleAtFixedRate(r, 1, 2, TimeUnit.SECONDS);
    }
}

3 使用Spring Task

Spring Task 底层是基于 JDK 的 ScheduledThreadPoolExecutor 线程池来实现的。直接通过Spring 提供的 @Scheduled 注解即可定义定时任务，非常方便。

以Spring Boot来作为示例，步骤为

  1. 在启动类所在包下创建Schedule 类（在没有配置@ComponentScan的情况下，Spring Boot只会默认扫描启动类所在包的spring组件）
  2. 在该类上添加@Component和@EnableScheduling注解
  3. 在方法上添加@Scheduled注解，该注解主要参数如下
String cron() default "";  // 支持cron表达式

long fixedDelay() default -1;  // 在最后一次调用结束和下一次调用开始之间的时间间隔，以毫秒为单位
String fixedDelayString() default "";  // 同上，类似ScheduledExecutorService的scheduleWithFixedDelay

long fixedRate() default -1;  // 在调用之前的时间间隔，以毫秒为单位
String fixedRateString() default "";  // 同上，类似ScheduledExecutorService的scheduleAtFixedRate

long initialDelay() default -1;  // 在第一次执行fixedRate()或fixedDelay()任务之前要延迟的毫秒数
String initialDelayString() default "";  // 同上

代码示例：

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

import java.time.LocalDateTime;

@Component
@EnableScheduling
public class Schedule {
    @Scheduled(fixedRate = 2000L)
    public void task() {
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }
}

优点： 简单，轻量，支持 Cron 表达式缺点 ：默认只支持单机，是单线程的，并且提供的功能比较单一

可以通过@EnableAsync和 @Async开启多线程

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

import java.time.LocalDateTime;

@Component
@EnableAsync  // 开启异步多线程
@EnableScheduling
public class Schedule {

    @Async
    @Scheduled(fixedRate = 2000L)
    public void task() {
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }
}

使用@EnableAsync注解后，默认情况下，Spring将搜索关联的线程池定义：上下文中的唯一org.springframework.core.task.TaskExecutor
的bean，或者名为“taskExecutor”的java.util.concurrent.Executor
的bean。如果两者都无法解析，则将使用org.springframework.core.task.SimpleAsyncTaskExecutor来处理异步方法调用。

TaskExecutor实现为每个任务启动一个新线程，异步执行它。 支持通过“concurrencyLimit”bean 属性限制并发线程。默认情况下，并发线程数是无限的，所以使用默认的线程池有导致内存溢出的风险。

注意：刚才的运行结果看起来是线程复用的，而实际上此实现不重用线程！应尽量实现一个线程池TaskExecutor ，特别是用于执行大量短期任务。不要使用默认的SimpleAsyncTaskExecutor。

import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.Executor;

@Component
@EnableAsync
@EnableScheduling
public class Schedule {

    @Async
    @Scheduled(fixedRate = 2000L)
    public void task() {
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }


    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(10);
        taskExecutor.setMaxPoolSize(50);
        taskExecutor.setQueueCapacity(200);
        taskExecutor.setKeepAliveSeconds(60);
        taskExecutor.setThreadNamePrefix("自定义-");
        taskExecutor.setAwaitTerminationSeconds(60);
        return taskExecutor;
    }
}

上面提到的一些定时任务的解决方案都是在单机下执行的，适用于比较简单的定时任务场景比如每天凌晨备份一次数据。如果我们需要一些高级特性比如支持任务在分布式场景下的分片和高可用的话，我们就需要用到分布式任务调度框架了，比如Quartz、Elastic-Job、XXL-JOB、PowerJob，本文就不再详细进行介绍了，感兴趣的可以自行查阅相关资料。

总结 

到此这篇关于Java项目实现定时任务的三种方法的文章就介绍到这了,更多相关Java定时任务实现内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

您可能感兴趣的文章:
  • Java使用quartz实现定时任务示例详解
  • 一文搞懂如何实现Java,Spring动态启停定时任务
  • Java实现定时任务最简单的3种方法
  • java定时任务cron表达式每周执行一次的坑及解决
  • Java使用线程池执行定时任务
  • java开发主流定时任务解决方案全横评详解

Java 定时任务系列（2）-Spring 定时任务的几种实现

Java 定时任务系列（2）-Spring 定时任务的几种实现

本文来自网络一些博客的整理（包括gong1208的博客 dary1715的博客）
1、简介
这个系列介绍Spring框架实现定时任务的两种方式以及一些高级的用法，包括：
1、使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
2、Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。

2、Quartz的使用
作业类继承自特定基类的方式：org.springframework.scheduling.quartz.QuartzJobBean

①定义作业类：

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class Job1 extends QuartzJobBean {
    private int timeout;
    private static int i = 0;
    //调度工厂实例化后，经过timeout时间开始执行调度
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
    /**
    * 要调度的具体任务
    */
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("定时任务执行中…");
    }
}

②spring配置文件中配置作业类JobDetailBean

<bean name="job1">
    <property name="jobClass" value="com.gy.Job1" />
    <property name="jobDataAsMap">
        <map>
            <entry key="timeout" value="0" />
        </map>
    </property>
</bean>

说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAs

③配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

<bean id="simpleTrigger">
    <property name="jobDetail" ref="job2" />
    <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->
    <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->
</bean>

第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

<bean id="cronTrigger">
    <property name="jobDetail" ref="job2" />
    <!—每天12:00运行一次 -->
    <property name="cronExpression" value="0 0 12 * * ?" />
</bean>

④配置调度工厂

<bean>
    <property name="triggers">
        <list>
            <ref bean="cronTrigger" />
        </list>
    </property>
</bean>

⑤启动你的应用即可，即将工程部署至tomcat或其他容器。
到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。

其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具 请看我第下文Spring task的介绍。
特别的，关于CronExpression 的详细用户，请参考dary1715的博客

3、Spring Task
上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级
的Quartz，而且使用起来很简单，除spring相 关的包外不需要额外的包，而且支持注解和配置文件两种
形式，下面将分别介绍这两种方式。

配置文件方式：

①配置作业类
即普通的pojo，如下：

import org.springframework.stereotype.Service;
@Service
public class TaskJob {

    public void job1() {
        System.out.println(“task exe...”);
    }
}

②在spring配置文件头中添加命名空间及描述

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:task="http://www.springframework.org/schema/task" 
xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

③spring配置文件中设置具体的任务

<task:scheduled-tasks> 
    <task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/> 
</task:scheduled-tasks>
<context:component-scan base-package=" com.gy.mytask " />

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。

这个配置不消多说了，spring扫描注解用的。

到这里配置就完成了，是不是很简单。

使用注解形式:

① 编写普通的POJO

import org.springframework.scheduling.annotation.Scheduled;  
import org.springframework.stereotype.Component;
@Component(“taskJob”)
public class TaskJob {
@Scheduled(cron = "0 0 3 * * ?")
    public void job1() {
        System.out.println(“任务进行中。。。”);
    }
}

②添加task相关的配置：

<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"
default-lazy-init="false">


<context:annotation-config />
<!—spring扫描注解的配置   -->
<context:component-scan base-package="com.gy.mytask" />
<!—开启这个配置，spring才能识别@Scheduled注解   -->
<task:annotation-driven scheduler="qbScheduler" mode="proxy"/>
<task:scheduler id="qbScheduler" pool-size="10"/>

其他关于Spring Task使用的例子请参照 参考链接1 参考链接2

java 定时器，固定某个时间执行（Spring+Quartz实现定时任务的配置方法）

java 定时器，固定某个时间执行（Spring+Quartz实现定时任务的配置方法）

1.Scheduler的配置

<bean id="myScheduler">
        <property name="triggers">
            <list>
                <ref bean="myTriggersA"></ref>
                <ref bean="myTriggersB"></ref>
            </list>
        </property>
        <property name="autoStartup" value="true"></property>
    </bean>

2.Trigger的配置

<bean id="myTriggersA">
        <property name="jobDetail" ref="myJobDetailA">
        </property>
        <property name="cronExpression">
            <value>0/1 * * * * ?</value>
        </property>
    </bean>

说明：

         1）Cron表达式的格式：秒 分 时 日 月 周 年(可选)。

               字段名                 允许的值                        允许的特殊字符  

               秒                         0-59                               , - * /  

               分                         0-59                               , - * /  

               小时                   0-23                               , - * /  

               日                         1-31                               , - * ? / L W C  

               月                         1-12 or JAN-DEC          , - * /  

               周几                     1-7 or SUN-SAT            , - * ? / L C #  

               年 (可选字段)     empty, 1970-2099      , - * /

               “?”字符：表示不确定的值

               “,”字符：指定数个值

               “-”字符：指定一个值的范围

               “/”字符：指定一个值的增加幅度。n/m表示从n开始，每次增加m

               “L”字符：用在日表示一个月中的最后一天，用在周表示该月最后一个星期X

               “W”字符：指定离给定日期最近的工作日(周一到周五)

               “#”字符：表示该月第几个周X。6#3表示该月第3个周五

         2）Cron表达式范例：

                 每隔5秒执行一次：*/5 * * * * ?

                 每隔1分钟执行一次：0 */1 * * * ?

                 每天23点执行一次：0 0 23 * * ?

                 每天凌晨1点执行一次：0 0 1 * * ?

                 每月1号凌晨1点执行一次：0 0 1 1 * ?

                 每月最后一天23点执行一次：0 0 23 L * ?

                 每周星期天凌晨1点实行一次：0 0 1 ? * L

                 在26分、29分、33分执行一次：0 26,29,33 * * * ?

                 每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

"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期间的每1分钟触发

"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发

"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发

"0 10,44 14 ? 3 WED" 每年三月的星期三的下午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" 每月的第三个星期五上午10:15触发

每天早上6点

0 6 * * *

每两个小时

0 */2 * * *

晚上11点到早上8点之间每两个小时，早上八点

0 23-7/2，8 * * *

每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点

0 11 4 * 1-3

1月1日早上4点

0 4 1 1 *

3.JobDetail的配置

<bean id="myJobDetailA">
        <property name="targetObject" ref="myJobA">
        </property>
        <property name="targetMethod" value="work"></property>
        <property name="concurrent" value="false" />
        <!-- 是否允许任务并发执行。当值为false时，表示必须等到前一个线程处理完毕后才再启一个新的线程 -->
    </bean>

4.业务类的配置

<bean id="myJobA">
    </bean>　　

5.业务类代码

import java.util.Date;

public class MyJobA {

    public void work() {
        System.out.println("date: " + new Date().getTime());
    }
}

说明：业务类不需要继承任何父类，也不需要实现任何接口，只是一个普通的java类。

Java 实现定时任务的三种方法

Java 实现定时任务的三种方法

这篇文章主要介绍了Java 实现定时任务的三种方法，帮助大家更好的理解和学习使用Java，感兴趣的朋友可以了解下

目录

1、 sleep

2、Timer

3、scheduledexecutorservice

总结

是的，不用任何框架，用我们朴素的 Java 编程语言就能实现定时任务。

今天，栈长就介绍 3 种实现方法，教你如何使用 JDK 实现定时任务！

1、 sleep

这也是我们最常用的 sleep 休眠大法，不只是当作休眠用，我们还可以利用它很轻松的能实现一个简单的定时任务。实现逻辑：新开一个线程，添加一个 for/ while 死循环，然后在死循环里面添加一个 sleep 休眠逻辑，让程序每隔 N 秒休眠再执行一次，这样就达到了一个简单定时任务的效果。实现代码如下：private static void sleepTask() { new Thread(() -> { while (true) { System.out.println("hi, 欢迎关注：Java技术栈"); try { // 每隔3秒执行一次 Thread.sleep(3000); } catch (InterruptedException e) { e.printstacktrace(); } } }).start(); }这种方式比较傻瓜化了，只能按固定频率运行，不能指定具体运行的时间。另外，上面的箭头语法，栈长使用了 JDK 8 中的 Lambda 表达式，这里就不再撰述了，Java 8 系列实战教程我都写了一堆了，不清楚的可以关注公众号：Java技术栈，在后台回复 "java" 阅读，我都整理好了。

2、Timer

来看下 JDK 自带的 java.util.Timer 类：

JDK 1.3 就内置了 java.util.Timer 类，可以用来调度 java.util.TimerTask 任务。

几个重要的方法：

schedule：开始调度任务，提供了几个包装方法；

cancle：终止任务调度，取消当前调度的所有任务，正在运行的任务不受影响；

purge：从任务队列中移除所有已取消的任务；

另外，java.util.TimerTask 就是实现了 Runnable 接口，具体任务逻辑则是在 run 方法里去实现。

实现代码如下：

private static void timerTask() throws InterruptedException { Timer timer = new Timer(); TimerTask timerTask = new TimerTask() { @Override public void run() { System.out.println("hi, 欢迎关注：Java技术栈"); } }; // 第一次任务延迟时间 long delay = 2000; // 任务执行频率 long period = 3 * 1000; // 开始调度 timer.schedule(timerTask, delay, period); // 指定首次运行时间 // timer.schedule(timerTask, DateUtils.addSeconds(new Date(), 5), period); Thread.sleep(20000); // 终止并移除任务 timer.cancel(); timer.purge(); }

这种实现方式比较简单，可以指定首次执行的延迟时间、首次执行的具体日期时间，以及执行频率，能满足日常需要。

另外，需要注意的是，Timer 是线程安全的，因为背后是单线程在执行所有任务。

Timer 也会有一些缺陷：

Timer 是单线程的，假如有任务 A,B,C，任务 A 如果执行时间比较长，那么就会影响任务 B,C 的启动和执行时间，如果 B,C 执行时间也比较长，那就会相互影响；

Timer 不会捕获异常，如果 A,B,C 任何一个任务在执行过程中发生异常，就会导致 TImer 整个定时任务停止工作；

Timer 是基于绝对时间调度的，而不是基于相对时间，所以它对系统时间的改变非常敏感；

所以，如果在使用 Timer 的过程中要注意这些缺陷，虽然可以用，但不推荐。

3、scheduledexecutorservice

因 Timer 有一些缺陷，所以不太建议使用 Timer，推荐使用 scheduledexecutorservice：

scheduledexecutorservice 即是 Timer 的替代者，JDK 1.5 并发包引入，是基于线程池设计的定时任务类：

java.util.concurrent.Executors.newScheduledThreadPool

上了线程池，每个调度任务都会分配到线程池中的某一个线程去执行，任务就是并发调度执行的，任务之间互不影响。

几个重要的调度方法：

schedule：只执行一次调度；

scheduleAtFixedrate：按固定频率调度，如果执行时间过长，下一次调度会延迟，不会同时执行；

scheduleWithFixedDelay：延迟调度，上一次执行完再加上延迟时间后执行；

另外，可以看出，任务是支持 Runnable 和 Callable 调度的。

实现代码如下：

public static void poolTask(){ scheduledexecutorservice pool = Executors.newScheduledThreadPool(10); pool.scheduleAtFixedrate(() -> { System.out.println("hi, 欢迎关注：Java技术栈"); }, 2000, 3000, TimeUnit.MILLISECONDS); }

这是一个按固定频率调度的任务，创建了 10 个核心线程数，首次执行延迟 2 秒，后续每 3 秒执行一次。

这种方式简单、好用，避免了使用 Timer 带来的各种问题，推荐使用这种实现方式。

总结

好了，本文栈长分享了 3 种 Java 实现定时任务的方式，也相对简单，但执行频率时间设置都太简单，只适合简单的业务，不适合实际复杂业务的需求，实际业务要考虑分布式、故障转移恢复等远要复杂的多。

本文仅给大家一个参考吧，在不用框架的前提下也能实现定时任务，在小而美的场景，还是很香的。

最后，Java 系列教程还会继续更新，关注Java技术栈公众号第一时间推送，还可以在公众号菜单中获取历史 Java 教程，都是干货。

本节教程所有实战源码已上传到这个仓库：

https://github.com/javastacks/javastack

最后，觉得我的文章对你用收获的话，动动小手，给个在看、转发，原创不易，栈长需要你的鼓励。

以上就是Java 实现定时任务的三种方法的详细内容，更多关于Java 实现定时任务的资料请关注小编其它相关文章！

JavaScript函数定时器：实现定时任务的实用工具

JavaScript函数定时器：实现定时任务的实用工具

javascript函数定时器：实现定时任务的实用工具

JavaScript函数定时器：实现定时任务的实用工具

随着现代Web应用的发展，我们经常需要在特定的时间间隔内执行某些任务。JavaScript提供了一种非常实用的工具，即函数定时器（function timer），它可以帮助我们实现定时任务的功能。本文将介绍JavaScript函数定时器的原理和使用方法，并提供一些具体的代码示例。

函数定时器的原理

函数定时器是JavaScript中的一种功能强大的定时工具，它可以让我们在指定的时间间隔内执行一段代码。JavaScript提供了两种类型的函数定时器，分别是setInterval函数和setTimeout函数。

立即学习“Java免费学习笔记（深入）”；

setInterval函数是用来重复执行一段代码，它接受两个参数，分别是要执行的代码块和时间间隔。例如，下面的代码将每隔1秒输出一次"Hello, World!"：

setInterval(() => {
  console.log("Hello, World!");
}, 1000);
登录后复制

上述代码中，箭头函数（() => {}）后面的时间间隔为1000毫秒，即1秒。每隔1秒，控制台就会输出一次"Hello, World!"。

setTimeout函数用于在指定的时间间隔后执行一段代码，它接受两个参数，分别是要执行的代码块和时间间隔。例如，下面的代码将在1秒后输出一次"Hello, World!"：

setTimeout(() => {
  console.log("Hello, World!");
}, 1000);
登录后复制

上述代码中，箭头函数后面的时间间隔为1000毫秒，即1秒。1秒后，控制台就会输出一次"Hello, World!"。

函数定时器的使用方法

函数定时器的使用非常简单。我们只需要将要执行的代码放入一个函数中，然后再将这个函数作为参数传递给setInterval函数或setTimeout函数即可。下面是一个使用setInterval函数实现每隔5秒输出当前时间的例子：

setInterval(() => {
  const now = new Date();
  const hours = now.getHours();
  const minutes = now.getMinutes();
  const seconds = now.getSeconds();
  console.log(`${hours}:${minutes}:${seconds}`);
}, 5000);
登录后复制

上述代码中，箭头函数中的代码将会每隔5秒执行一次。每次执行时，它会获取当前的时间并输出到控制台中。

除了常规的代码执行外，我们还可以使用函数定时器来执行其他类型的任务，比如动画效果的更新、定时提交表单等等。只需要将相关的代码放入一个函数中，并根据具体需求选择使用setInterval函数或setTimeout函数即可。

定时器的取消

有时候，我们需要在某个特定的条件下取消函数定时器，以停止某个周期性任务的执行。JavaScript提供了clearInterval函数和clearTimeout函数来实现定时器的取消。

clearInterval函数用于取消由setInterval函数创建的函数定时器。它需要接收一个setInterval函数的返回值作为参数。例如，下面的代码将在5秒后取消函数定时器：

const intervalId = setInterval(() => {
  console.log("Hello, World!");
}, 1000);

setTimeout(() => {
  clearInterval(intervalId);
}, 5000);
登录后复制

上述代码中，先使用setInterval函数创建了一个函数定时器，并将返回的值保存到intervalId变量中。然后，使用setTimeout函数在5秒后调用clearInterval函数来取消函数定时器。

同样地，clearTimeout函数用于取消由setTimeout函数创建的函数定时器。它也需要接收一个setTimeout函数的返回值作为参数。

总结

JavaScript函数定时器是一种非常实用的工具，它可以帮助我们实现定时任务的功能。我们可以使用setInterval函数重复执行一段代码，也可以使用setTimeout函数在一段时间后执行一段代码。函数定时器的使用非常简单，只需要将要执行的代码放入一个函数中，并根据需求选择合适的函数定时器即可。另外，我们还可以使用clearInterval函数和clearTimeout函数来取消函数定时器。通过合理运用函数定时器，我们可以更好地控制和处理定时任务，提升Web应用的用户体验和功能性。

以上就是JavaScript函数定时器：实现定时任务的实用工具的详细内容，更多请关注php中文网其它相关文章！

关于Java项目实现定时任务的三种方法和java项目实现定时任务的三种方法是什么的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Java 定时任务系列（2）-Spring 定时任务的几种实现、java 定时器，固定某个时间执行（Spring+Quartz实现定时任务的配置方法）、Java 实现定时任务的三种方法、JavaScript函数定时器：实现定时任务的实用工具等相关内容，可以在本站寻找。

本文标签：

上一篇使用 xml 和属性文件的带有 javadocs 和源的 Netbeans java jar（使用xmlinclude 或soapinclude）

下一篇java实现日历功能（java实现简单的日历功能）

相关文章