分布式job-任务调度（一）

什么是任务调度：

任务调度：在单位时间内,去调用某个方法或者执行某段代码

java实现方式：

方法一（使用线程实现）：

    public static void ThreadTskScheduling() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                        System.out.println("执行一次:" + count++);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }).start();
    }

方法二（使用timerTask)：

public static void timerTaskTskScheduling() {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                // 执行任务代码
                System.out.println("执行一次:" + count++);
            }
        };

        Timer timer = new Timer();
        // 任务执行前的毫秒延迟。
        long delay = 0;
        // 间隔的秒数
        long period = 1000;
        timer.scheduleAtFixedRate(timerTask, delay, period);
    }

方法三（使用定时线程池）：

public static void ExecutorsTaskTskScheduling() {
        Runnable runnable = new Runnable() {
            public void run() {
                System.out.println("执行一次:" + count++);
            }
        };
        // 定时线程池
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间，最后表示时间单位  表示启动以后延迟5秒执行，执行间隔是1秒
        service.scheduleAtFixedRate(runnable, 5, 1, TimeUnit.SECONDS);
    }

 

方法四（使用springboot自带的定时任务）：

package com.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
//整合常见注解，扫包作用（当前同级目录）
@SpringBootApplication
@EnableAsync 
@EnableScheduling   // 2.开启定时任务
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

package com.springboot.scheduledtasks;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {
    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime() {
        System.out.println("任务1：" + dateFormat.format(new Date()));
    }

}

 实现方式五（使用quartz）：

package com.example.demo;

import java.util.Date;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class JobStart {
    public static void main(String[] args) throws SchedulerException {
        // https://www.w3cschool.cn/quartz_doc/quartz_doc-jop62d45.html
        // 1.创建Scheduler的工厂
        SchedulerFactory sf = new StdSchedulerFactory();
        // 2.从工厂中获取调度器实例
        Scheduler scheduler = sf.getScheduler();

        // 3.创建JobDetail
        JobDetail jb = JobBuilder.newJob(MyJob.class).withDescription("jiahou.quartz") // job的描述
                .withIdentity("jiahou", "jiahouJob") // job 的name和group
                .build();

        // 任务运行的时间，SimpleSchedle类型触发器有效
        long time = System.currentTimeMillis() + 3 * 1000L; // 3秒后启动任务
        Date statTime = new Date(time);
        // 4.创建Trigger
        Trigger t = TriggerBuilder.newTrigger().withDescription("").withIdentity("ramTrigger", "ramTriggerGroup")
                .startAt(statTime) // 默认当前时间启动
                .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")) // 两秒执行一次
                .build();

        // 5.注册任务和定时器
        scheduler.scheduleJob(jb, t);
        // 6.启动 调度器
        scheduler.start();
        // 停止
        // scheduler.shutdown();

    }
}

package com.example.demo;

import java.util.Date;

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

public class MyJob implements Job {

    // 执行任务调度方法
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("执行任务:" + System.currentTimeMillis());
    }

}

以上都是可以解决任务调度的方法，但在实际项目中，一般都是使用第三方quartz实现任务调度功能，既然已经有了quartz为什么还需要使用xxl-job呢？

 

参考：https://www.w3cschool.cn/quartz_doc/quartz_doc-jop62d45.html