Java-定时任务

参考

https://mp.weixin.qq.com/s/DD7AngUgYtVui0qqZzKHRw

实现方式

线程+休眠

public class JobThread {
    public static class Demo01 {
        static long count = 0;

        public static void main(String[] args) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            Thread.sleep(1000);
                            count++;
                            System.out.println(count);
                        } catch (Exception e) {
                            // TODO: handle exception
                        }
                    }
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
}

Timer、TimerTask

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

/**
 * TODO  使用 TimerTask 创建job定时任务
 * @author 王松
 */
public class JobTimerTask {

    static long count = 0;
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                count++;
                System.out.println(count);
            }
        };
        //创建timer对象设置间隔时间
        Timer timer = new Timer();

        // 延迟 1s, 打印 wtf 一次
        // timer.schedule(timerTask, 1000);
        // 延迟 1s, 固定时延每隔 1s 周期打印一次 wtf
        // timer.schedule(timerTask, 1000, 1000);
        // 延迟 1s, 固定速率每隔 1s 周期打印一次 wtf
        timer.scheduleAtFixedRate(timerTask, 1000, 1000);
    }
}

Executors、ScheduledExecutorService

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

/**
 * TODO  使用线程池创建 job定时任务
 * @author 王松
 */
public class JobScheduledExecutorService {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // task to run goes here
                System.out.println("Hello !!");
            }
        };
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        //ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        // 延期 10s 执行
        service.schedule(runnable, 10, TimeUnit.SECONDS);
      
        // 延期 1s, 以固定速率每隔 1s 执行一次
        // service.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);
      
        service.scheduleWithFixedDelay(
                new Runnable() {
                    @Override
                    public void run() {
                        // 执行任务的业务代码
                        System.out.println("执行任务" +
                                " ，执行时间：" + LocalDateTime.now());
                    }
                },
                2, // 初次执行间隔
                2, // 2s 执行一次
                TimeUnit.SECONDS);
    }
}

Spring @Scheduled 注解

@Component
@EnableScheduling   // 开启定时任务
public class SaticScheduleTask {
     
    @Scheduled(cron = "0/5 * * * * ?")  //添加定时任务
    //@Scheduled(fixedRate=5000)        //或直接指定时间间隔，例如：5秒
    private void configureTasks() {
        System.err.println("执行静态定时任务时间: " + LocalDateTime.now());
    }
}

Quartz

1. pom.xml

   <dependencies>
    <!-- quartz -->
    <dependency>
     <groupId>org.quartz-scheduler</groupId>
     <artifactId>quartz</artifactId>
     <version>2.2.1</version>
    </dependency>
    <dependency>
     <groupId>org.quartz-scheduler</groupId>
     <artifactId>quartz-jobs</artifactId>
     <version>2.2.1</version>
    </dependency>
   </dependencies>

2. 任务调度类

   public class MyJob implements Job {
   
       @Override
       public void execute(JobExecutionContext context) throws JobExecutionException {
           System.out.println("quartz MyJob date:" + System.currentTimeMillis());
       }
   }

3. 启动类

   public class JobQuartz {
   
       public static void main(String[] args) throws SchedulerException {
           //1.创建Scheduler的工厂
           SchedulerFactory sf = new StdSchedulerFactory();
           //2.从工厂中获取调度器实例
           Scheduler scheduler = sf.getScheduler();
           //3.创建JobDetail，
           JobDetail jb = JobBuilder.newJob(MyJob.class)
                   //job的描述
                   .withDescription("this is a ram job")
                   //job 的name和group
                   .withIdentity("ramJob", "ramGroup")
                   .build();
           //任务运行的时间，SimpleSchedle类型触发器有效，3秒后启动任务
           long time=  System.currentTimeMillis() + 3*1000L;
           Date statTime = new Date(time);
           //4.创建Trigger
           //使用SimpleScheduleBuilder或者CronScheduleBuilder
           Trigger t = TriggerBuilder.newTrigger()
                   .withDescription("")
                   .withIdentity("ramTrigger", "ramTriggerGroup")
                   //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
                   //默认当前时间启动
                   .startAt(statTime)
                   //两秒执行一次，Quartz表达式，支持各种牛逼表达式
                   .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
                   .build();
           //5.注册任务和定时器
           scheduler.scheduleJob(jb, t);
           //6.启动 调度器
           scheduler.start();
       }

xxl-job

参考《xxl-job》