Java如何实现定时任务

Java中实现定时任务的方式有多种，主要包括使用Timer和TimerTask类、使用ScheduledExecutorService接口、使用cron表达式和使用Quartz框架。

1. 使用Timer和TimerTask类

Timer是一种简单的任务调度器，用于按照指定的时间间隔执行任务。TimerTask是Timer中的任务，可以继承TimerTask类并重写run()方法来实现我们需要执行的任务。

示例代码1：

import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行定时任务1");
            }
        };
        // 第一个参数为任务，第二个参数为定时任务第一次执行的延迟时间，第三个参数为两个任务执行的间隔时间
        timer.schedule(task, 0, 1000);
    }
}

示例代码2：

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

public class TimerTest {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行定时任务2，时间：" + new Date()); 
            }
        };
        // 第一个参数为任务，第二个参数为定时任务第一次执行的时间
        timer.schedule(task, new Date(System.currentTimeMillis() + 5000)); 
        // 第一个参数为任务，第二个参数为定时任务第一次执行的时间，第三个参数为两个任务执行的间隔时间
        timer.schedule(task, new Date(System.currentTimeMillis() + 5000), 2000); 
    }
}

1. 使用ScheduledExecutorService接口

ScheduledExecutorService是Java中一个基于线程池设计的定时任务调度器，可以使用它来替代Timer。ScheduledExecutorService提供两种调度方式，分别为按固定时间间隔调度和按固定时间执行。

示例代码3：

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

public class ScheduledExecutorServiceTest {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("执行定时任务3");
            }
        };
        // 第一个参数为任务，第二个参数为任务第一次执行的延迟时间，第三个参数为两个任务执行的间隔时间
        executor.scheduleAtFixedRate(task, 0, 1000, TimeUnit.MILLISECONDS);
    }
}

示例代码4：

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

public class ScheduledExecutorServiceTest {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("执行定时任务4，时间：" + new Date()); 
            }
        };
        // 第一个参数为任务，第二个参数为任务第一次执行的延迟时间，第三个参数为两个任务执行的间隔时间
        executor.scheduleAtFixedRate(task, 5, 2, TimeUnit.SECONDS);
    }
}

1. 使用cron表达式

cron表达式是一种通用的时间表达式，可以用于指定各种周期性事件的时间间隔。有两种常见的Java库可以解析cron表达式，分别是Quartz和Spring的Scheduled和SchedulingConfigurer。

示例代码5：

import org.quartz.CronExpression;

import java.util.Date;

public class CronExpressionTest {
    public static void main(String[] args) {
        String cron = "0/5 * * * * ?"; // 每隔5秒执行一次
        CronExpression expression = CronExpression.isValidExpression(cron) ? new CronExpression(cron) : null;
        if (expression != null) {
            Date nextDate = expression.getNextValidTimeAfter(new Date());
            System.out.println(nextDate);
        }
    }
}

1. 使用Quartz框架

Quartz是一个广泛使用的开源的Job调度框架，提供了很多高级功能。

示例代码6：

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

public class QuartzTest {
    public static void main(String[] args) throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job1", "group1")
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever())
                .build();

        scheduler.scheduleJob(jobDetail, trigger);

        scheduler.start();

        Thread.sleep(10000);

        scheduler.shutdown();
    }

    public static class MyJob implements Job {
        @Override
        public void execute(JobExecutionContext jobExecutionContext) {
            System.out.println("执行Quartz定时任务，时间：" + new Date());
        }
    }
}

以上就是Java实现定时任务的完整攻略，包括几种常见的方式及其示例。