java 定时器、定时任务接口、定时作业框架Quartz

import javafx.util.Duration;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author: ZhangHao
 * @Description: 5种定时Demo
 * @Date: 2020/3/26 15:16
 * @Version: 1.0
 */
public class TimerTest {
    public static void main(String[] args) throws SchedulerException, InterruptedException {
        new TimerTest().executeTimer();
//        new TimerTest().executeScheduledExecutorService();
//        new TimerTest().executeScheduledThreadPoolExecutor();
//        new TimerTest().executeScheduler();
    }

    Thread timerThread = null;
    // Timer由JDK提供
    public void executeTimer() {
        // 4000毫秒后启动，开始第一次执行，执行完成后等1000毫秒再次开始执行，重复此1000毫秒执行间隔
        Timer timer = new Timer("timer");
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                if(timerThread != null){
                    System.out.println("thread == Thread.currentThread():" + (timerThread == Thread.currentThread()));
                }

                timerThread = Thread.currentThread();
                System.out.println(Thread.currentThread().getName() + ":");
                for (int i = 1; i <= 100; i++) {
                    System.out.println(i);
                }
            }
        }, 4000, 1000);
//        timer.cancel();
    }

    // ScheduledExecutorService由JDK提供
    public void executeScheduledExecutorService() {
        // 10个线程，线程单次任务执行完成后，还有其他任务，就会被重新利用
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 10; i++) {
            // 每个线程延时4秒后启动
//            executor.schedule(() -> System.out.println(Thread.currentThread().getName() + " run"), 4, TimeUnit.SECONDS);
            // 每个线程延时4秒后启动，开始第一次执行，执行完成后等1秒再次开始执行，重复此1秒执行间隔
            executor.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName() + " run"), 4, 1, TimeUnit.SECONDS);
        }

//        executor.shutdown();
    }

    // ScheduledThreadPoolExecutor由JDK提供
    public void executeScheduledThreadPoolExecutor() {
        // 10个线程，线程单次任务执行完成后，还有其他任务，就会被重新利用
        // public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService
        ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 10; i++) {
            // 每个线程延时4秒后启动
//            executor.schedule(() -> System.out.println(Thread.currentThread().getName() + " run"), 4, TimeUnit.SECONDS);
            // 每个线程延时4秒后启动，开始第一次执行，执行完成后等1秒再次开始执行，重复此1秒执行间隔
            executor.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName() + " run"), 4, 1, TimeUnit.SECONDS);
        }

//        executor.shutdown();
    }

    // 使用quartz框架，定时按顺序执行工作
    public void executeScheduler() throws InterruptedException, SchedulerException{
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.start();
        JobKey jobKey = new JobKey("job-1" , "jobGroup-1");
        JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("job-1" , "jobGroup-1")
                // 延迟1000毫秒执行
                .startAt(new Date(System.currentTimeMillis() + 1000))
                // 每隔1秒执行，并一直重复
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                .build();
        scheduler.scheduleJob(jobDetail , trigger);
        Thread.sleep(6000);
//        scheduler.deleteJob(jobKey);
    }
}

import org.quartz.Job;
import org.quartz.JobExecutionContext;

/**
 * @Author: ZhangHao
 * @Description: Job实现
 * @Date: 2020/3/26 15:16
 * @Version: 1.0
 */
public class TestJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext){
        System.out.println(Thread.currentThread().getName() + " test job begin");
    }
}

 

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

Java 定时作业框架Quartz遇到的问题可参考：https://blog.csdn.net/haoranhaoshi/article/details/102897898