elastic-job中任务调度常见的4种方式1

一.任务调度概念

1.1 任务调度概念

任务调度是指系统为了自动完成特定的任务，在约定的特点时间去执行任务的过程，解放人力需要做的事情。

工程资料见百度网盘：

1.2 调度方式

1多线程

2.timer，

3.线程池 scheduleExecutorservice

4.quarts

区别在于前面3个只能间隔执行，qurats可以间隔，也可以在某个时刻执行。

二.实现案例介绍

2.1 多线程方式

特点：开启一个线程，每sleep一段时间，就去检查是否到达预期执行时间。

package com.ljf.elastic.job.simple.task;

import java.util.Date;

public class ThreadTask  implements Runnable {
    @Override
    public void run() {
        while(true) {
            System.out.println(new Date().getTime()+"定时任务");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.ljf.elastic.job.simple.task;

public class ThreadDemo {
    public static void main(String args[]){
        new Thread(new ThreadTask()).start();
    }
}

2.2 使用timer方式

特点： 设置指定任务task在指定延迟delay后进行固定延迟peroid的执行；意思是当程序获取执行权开始执行时，再按照delay设置的延迟值，等待xx秒后执行，peroid，表示按什么周期频率去执行。每个Timer对应一个线程，因此可以同时启动多个Timer并行执行多个任务，同一个Timer中的任务是串行执行。

package com.ljf.elastic.job.simple.task;

import javax.xml.crypto.Data;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo {
    /**
     *   第二种方法：设定指定任务task在指定延迟delay后进行固定延迟peroid的执行
     *   意思是当程序获取执行权开始执行时，再按照dalay设置的延迟值，等待xx秒后执行，
     *   period，表示按什么周期频率去执行。
     *
     *
     *
     */

    public static void main(String args[]){
    Timer t=new Timer();
    t.schedule(new TimerTask() {
        @Override
        public void run() {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateString = simpleDateFormat.format(new Date());
            System.out.println(dateString+"定时任务");
        }
    },1000, 5000);
    }
}

2.3 使用线程池调度（scheduledExecutorService）

特点：每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。

package com.ljf.elastic.job.simple.task;

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

/**
 * 使用第3种方式：使用周期性线程池调度ScheduledExecutorService
 */
public class ThreadPoolSchedule {
    public static void main(String args[]){
        ScheduledExecutorService es= Executors.newScheduledThreadPool(10);
        es.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
            System.out.println(Thread.currentThread().getName()+" "+ LocalDateTime.now()+"do somethings");
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },5,2, TimeUnit.SECONDS);
    }
}

2.4 使用quarts方式

特点：Quartz是一个功能强大的任务调度框架，它可以满足更多更复杂的调度需求，Quartz设计的核心类包括 Scheduler,Job以及Trigger。其中，Job负责定义需要执行的任务，Trigger负责设置调度策略，Scheduler将二者组装在一起，并触发任务开始执行。Quartz支持简单的按时间间隔调度、还支持按日历调度方式，通过设置 CronTrigger表达式（包括：秒、分、时、日、月、周、年）进行任务调度

1.编写调度类

package com.ljf.elastic.job.simple.task;

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

/**
 * 第4种调度方式：使用qurats
 */
public class QurartsTask {
    public static void main(String args[]) throws SchedulerException {
    //创建一个sceduler
        SchedulerFactory schedulerFactory=new StdSchedulerFactory();
        Scheduler scheduler=schedulerFactory.getScheduler();
        //创建jobDetail
        JobBuilder jobBuilder=JobBuilder.newJob(MyJob.class);
        jobBuilder.withIdentity("jobname","nnd");
        JobDetail jobDetail=jobBuilder.build();
        //创建除非cronTrigger，支持按日历调度
        CronTrigger trigger=TriggerBuilder.newTrigger().withIdentity("mb","nd")
                .startNow().withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).build();//每2秒执行一次
        //创建间隔调度
        /**
        SimpleTrigger simpleTrigger=TriggerBuilder.newTrigger().withIdentity("aaa","bbb")
                .startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                .build();
         **/
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();





    }
}

编写执行job类： 

package com.ljf.elastic.job.simple.task;

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

import java.time.LocalDateTime;

public class MyJob  implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println(Thread.currentThread().getName()+" "+ LocalDateTime.now()+ "  do somethings");
    }
}