Java定时任务调度工具

理论基础

小顶堆

可以看一下下面这篇文章，了解一下小顶堆简单算法。
数据结构——小顶堆的构建，添加，删除

时间伦算法

时间论算法：https://blog.acolyer.org/2015/11/23/hashed-and-hierarchical-timing-wheels/

1、JDK定时器timer使用

package com.why.timer;

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();//任务的启动
        for (int i = 0; i < 2; i++) {
            TimerTask timerTask = new FooTimerTaks("foo" + i);
            //添加任务  其中period理论上表示每个任务的间隔时间为两秒，但实际的执行时间是上个任务的结束时间。
            timer.schedule(timerTask,new Date(),2000);
        }
    }
}

class FooTimerTaks extends TimerTask {

    private String name;

    FooTimerTaks(String name){
        this.name = name;
    }

    @Override
    public void run() {
        try {
            System.out.println("name+" + name + ",startTime= "+ new Date());
            Thread.sleep(3000);
            System.out.println("name+" + name + ",endTime= "+ new Date());

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

当调用schedule函数是实际的开始时间是上一次任务的结束时间

2、定时任务线程池解析

package com.why.pool;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduleThreadPoolTesl {

    public static void main(String[] args) {

        ScheduledExecutorService scheduledExecutorPool = Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 2; i++) {
            scheduledExecutorPool.scheduleAtFixedRate(new Task("task_" + i),0,2, TimeUnit.SECONDS);
        }
    }

}

class Task implements Runnable {
    private String name;

    Task(String name) {
        this.name = name;
    }


    @Override
    public void run() {
        try {
            System.out.println("name+" + name + ",startTime= " + new Date());
            Thread.sleep(3000);
            System.out.println("name+" + name + ",endTime= " + new Date());

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3、定时任务框架-quartz

自定义任务

package com.why.quartz;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
//        System.out.println("MyJob executer:" + new Date());

        //获取jobDetail 和 trigger 中的 参数
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        JobDataMap triggerMap = context.getTrigger().getJobDataMap();

        //将两个map合到一起，如果key重复就会被覆盖
        JobDataMap mergedMap = context.getMergedJobDataMap();

        System.out.println("JopDetailMap=" + jobDataMap.getString("job"));
        System.out.println("TriggerMap=" + triggerMap.getString("trigger"));
        System.out.println("MergedMap=" + mergedMap.getString("job"));
        System.out.println("MergedMap=" + mergedMap.getString("trigger"));
    }
}

调用工作

package com.why.quartz;

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

public class TestJob {
    public static void main(String[] args) {
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job1", "job-group1")
                .usingJobData("job", "jobDetail")
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "trigger-group1")
                .usingJobData("trigger", "trigger")
                .startNow()
                .withSchedule(
                        SimpleScheduleBuilder.simpleSchedule()
                                .withIntervalInSeconds(1)//间隔时间
                                .repeatForever())//一直重复执行
                .build();

        try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            scheduler.scheduleJob(jobDetail, trigger);
            //启动
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}