分布式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