定時任務排程

基於給定的時間點，給定的時間間隔或者給定的執行次數自動執行的任務

定時任務工具

Timer
Quartz

Timer能完成一些簡單的定時任務，能實現具體某個時間執行任務。只有一個後臺執行定時任務。
Quartz能實現更復雜的定時任務，比如每個星期、月份執行的定時任務。能通過後臺執行緒池來執行定時任務。

Timer

有且僅有一個後臺執行緒對多個業務執行緒進行定時定頻率的排程。

這裡寫圖片描述

程式碼例項

MyTimerTask.java

import java.text.SimpleDateFormat;
import 
 java.util.Calendar;
import java.util.TimerTask;

/**
 * Created by PengHongfu 2018-09-04 11:10
 */
public class MyTimerTask extends TimerTask {

    private String name;
    private Integer count = 0;

    public MyTimerTask(String inputName) {
        name = inputName;
    }

    @Override
    public void 
 run() {

        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current exec time is: " + sf.format(calendar.getTime()));
        System.out.println("Current exec name is: " + name);
        count++;

    }

    public 
 String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

MyTimer.java

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;

/**
 * Created by PengHongfu 2018-09-04 11:13
 */
public class MyTimer {
    public static void main(String args[]){
        //1.建立一個timer例項
        Timer timer = new Timer();
        //2.建立一個MyTimerTask例項
        MyTimerTask myTimerTask = new MyTimerTask("NO.1");
        //3.通過timer定時定頻率呼叫mytimertask的業務邏輯

        //即第一次執行是在當前時間兩秒之後，之後每隔一秒鐘執行一次
        timer.schedule(myTimerTask,2000L,1000L);
     }
 }

Timer的定時排程函式

`schedule()、scheduleAtFixedRate()`

這裡寫圖片描述
myTimer.java

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;

/**
 * Created by PengHongfu 2018-09-04 11:13
 */
public class MyTimer {
    public static void main(String args[]) {
        //1.建立一個timer例項
        Timer timer = new Timer();
        //2.建立一個MyTimerTask例項
        MyTimerTask myTimerTask = new MyTimerTask("NO.1");
        //3.通過timer定時定頻率呼叫mytimertask的業務邏輯

        //即第一次執行是在當前時間兩秒之後，之後每隔一秒鐘執行一次
        //timer.schedule(myTimerTask,2000L,1000L);

        /**
         * --------------- schedule用法 ---------------
         */
        /**
         * 用法一.schedule(task,time) 在當前時間等於或者超過time時執行一次task
         */
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sf.format(calendar.getTime()));
        calendar.add(Calendar.SECOND, 3);//3s之後的時間

        //myTimerTask.setName("schedule1");
        //timer.schedule(myTimerTask,calendar.getTime());

        /**
         * 用法二.schedule(task,time,period) 在當前時間等於或者超過time時執行一次task,之後每隔period重複執行task
         */
        //myTimerTask.setName("schedule2");
        //timer.schedule(myTimerTask,calendar.getTime(),2000L);

        /**
         * 用法三.schedule(task,delay) 等待delay毫秒後執行且僅僅執行一次task
         */
        //myTimerTask.setName("schedule3");
        //timer.schedule(myTimerTask,2000L);

        /**
         * 用法四.schedule(task,delay,period) 等待delay毫秒後執行且僅僅執行task,之後每隔period執行一次
         */
        //myTimerTask.setName("schedule4");
        //timer.schedule(myTimerTask,3000L,3000L);
        /**
         * ---------------------- scheduleAtFixedRate用法 ----------------------
         */
        /**
         *  用法一：scheduleAtFixedRate(TimerTask task, long delay, long period)
         */
        //myTimerTask.setName("scheduleAtFixedRate1");
        //timer.scheduleAtFixedRate(myTimerTask,2000L,2000L);

        /**
         *  用法二：scheduleAtFixedRate(TimerTask task, Date firstTime,long period)
         */
        //myTimerTask.setName("scheduleAtFixedRate2");
        //timer.scheduleAtFixedRate(myTimerTask,calendar.getTime(),2000L);

        /**
         * ---------------------- scheduledExecutionTime方法 ----------------------
         * 返回此任務最近實際執行的已安排執行的時間
         */
        myTimerTask.setName("schedule");
        timer.schedule(myTimerTask, 2000L);
        System.out.println("scheduled time is:" + sf.format(myTimerTask.scheduledExecutionTime()));

    }
}

`cancel()`方法

TimerTask中的cancel()方法,取消當前類中的任務
Timer中的方法cancel()方法，取消其排程下的所有任務。

 */
public class MyTimerTask extends TimerTask {

    private String name;
    private Integer count = 0;
    public MyTimerTask(String inputName){
        name = inputName;
    }
    @Override
    public void run() {
        if(count < 3) {//執行三次之後取消執行
            Calendar calendar = Calendar.getInstance();
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("Current exec time is: " + sf.format(calendar.getTime()));
            System.out.println("Current exec name is: " + name);
            count++;
        }else{
            cancel();//終止執行
            System.out.println("Task cancel");
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

CancelTest.java

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

/**
 * cancel()方法
 * Created by PengHongfu 2018-09-04 16:30
 */
public class CancelTest {
    public static void main(String args[]) throws InterruptedException {
        Timer timer = new Timer();
        MyTimerTask task1 = new MyTimerTask("task1");
        MyTimerTask task2 = new MyTimerTask("task2");

        Date startTime = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("start time is:" + sf.format(startTime));
        timer.schedule(task1, 3000, 2000);
        timer.schedule(task2, 1000, 2000);

        //休眠5秒
        Thread.sleep(5000);

        Date cancelTime = new Date();
        System.out.println("cancel time is:" + sf.format(cancelTime));
        //取消所有任務
        timer.cancel();
        System.out.println("Tasks all canceled!");
    }
}

`scheduledExecutionTime()`方法

返回此任務最近實際執行的已安排執行的時間

  /**
 * ---------------------- scheduledExecutionTime方法 ----------------------
      * 返回此任務最近實際執行的已安排執行的時間
      */
     myTimerTask.setName("schedule");
     timer.schedule(myTimerTask, 2000L);
     System.out.println("scheduled time is:" + sf.format(myTimerTask.scheduledExecutionTime()));

schedule和scheduleAtFixedRate的區別

主要在於
* 首次計劃執行的時間早於當前的時間
* 任務執行所需時間超出任務的執行週期間隔

這裡寫圖片描述

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 計劃時間早於當前時間
 * Created by PengHongfu 2018-09-04 16:58
 */
public class DifferenceTest {

    public static void main(String args[]) {
        Timer timer = new Timer();

        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("start time is:" + sf.format(calendar.getTime()));
        calendar.add(Calendar.SECOND, -6);//時間設定為6秒前

        //測試兩個方法 在首次計劃執行時間早於當前時間的執行情況
        //timer.schedule...
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Schedule exec time is:" + sf.format(scheduledExecutionTime()));
                System.out.println("Task isbeing executed");
            }
        }, calendar.getTime(), 2000);

    }

}

schedule:
start time is:2018-09-06 11:01:09
Schedule exec time is:2018-09-06 11:01:09
Task isbeing executed
Schedule exec time is:2018-09-06 11:01:11
Task isbeing executed
Schedule exec time is:2018-09-06 11:01:13
Task isbeing executed

scheduleAtFixedRate:
start time is:2018-09-06 10:57:25
Schedule exec time is:2018-09-06 10:57:19
Task isbeing executed
Schedule exec time is:2018-09-06 10:57:21
Task isbeing executed
Schedule exec time is:2018-09-06 10:57:23
Task isbeing executed

這裡寫圖片描述

 public static void main(String args[]) {
        Timer timer = new Timer();

        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("start time is:" + sf.format(calendar.getTime()));
        //執行間隔為2s，執行時間消耗4s
        //timer.schedule....
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Schedule exec time is:" + sf.format(scheduledExecutionTime()));
                System.out.println("Task isbeing executed");

            }
        }, calendar.getTime(), 2000);

    }

schedule:
start time is:2018-09-06 11:07:54
Schedule exec time is:2018-09-06 11:07:54
Task isbeing executed
Schedule exec time is:2018-09-06 11:07:58
Task isbeing executed
Schedule exec time is:2018-09-06 11:08:02
Task isbeing executed
Schedule exec time is:2018-09-06 11:08:06

scheduleAtFixedRate:
start time is:2018-09-06 11:04:27
Schedule exec time is:2018-09-06 11:04:27
Task isbeing executed
Schedule exec time is:2018-09-06 11:04:29
Task isbeing executed
Schedule exec time is:2018-09-06 11:04:31
Task isbeing executed

Timer函式的綜合運用

這裡寫圖片描述

DancingRobot.java

import java.text.SimpleDateFormat;
import java.util.TimerTask;

/**
 * 跳舞機器人
 * Created by PengHongfu 2018-09-04 17:16
 */
public class DancingRobot extends TimerTask {
    @Override
    public void run() {
        //獲取最近的一次執行任務的時間
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Schedule exec time is:"+sf.format(scheduledExecutionTime()));
        System.out.println("Dancing......");
    }
}

WaterRobot.java

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

/**
 * 灌水機器人
 * Created by PengHongfu 2018-09-04 17:20
 */
public class WaterRobot extends TimerTask {
    private Timer timer;
    //最大容量為5L
    private Integer bucketCapacity = 0;

    public WaterRobot(Timer timer) {
        this.timer = timer;
    }

    @Override
    public void run() {
        //灌水直至桶滿
        if (bucketCapacity < 5) {
            System.out.println("Add 1L Water into the bucket!");
            bucketCapacity++;
        } else {
            //水滿取消執行
            cancel();
            System.out.println("The waterRobot has been aborted");
            //timer終止的任務數
            System.out.println("The number of canceled task:" + timer.purge());
            System.out.println("Current water is:" + bucketCapacity);
            try {
                Thread.sleep(2000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            timer.cancel();
                        System.out.println("all task has been aborted!");

        }
    }
}

Executor.java

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;

/**
 * Created by PengHongfu 2018-09-04 17:24
 */
public class Executor {
    public static void main(String args[]){
        Timer timer = new Timer();
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current time is:" + sf.format(calendar.getTime()));

        DancingRobot dr = new DancingRobot();
        WaterRobot wr = new WaterRobot(timer);
        timer.schedule(dr,calendar.getTime(),2000);
        timer.schedule(wr,calendar.getTime(),1000);
    }
}

Current time is:2018-09-06 11:30:27
Schedule exec time is:2018-09-06 11:30:27
Dancing......
Add 1L Water into the bucket!
Add 1L Water into the bucket!
Schedule exec time is:2018-09-06 11:30:29
Dancing......
Add 1L Water into the bucket!
Add 1L Water into the bucket!
Schedule exec time is:2018-09-06 11:30:31
Dancing......
Add 1L Water into the bucket!
The waterRobot has been aborted
The number of canceled task:1
Current water is:5
all task has been aborted!

Timer的缺陷

管理併發任務的缺陷
當任務丟擲異常的缺陷

Timer有且僅有一個執行緒去執行定時任務，如果存在多個任務，且任務時間過長，會導致執行效果與預期不符。
如果TimerTask丟擲RuntimeException，Timer會停止所有任務的執行。

Timer不適用對時效性要求較高的多工併發作業及對複雜任務的排程。

Quartz

OpenSymphony提供的強大的開源任務排程框架

強大的排程功能
靈活的應用方式
分散式和叢集能力

設計模式

Bulider模式、元件模式、Factory模式、鏈式寫法

這裡寫圖片描述

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>

HelloJo.java

import org.quartz.*;

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * 實現業務邏輯的介面
 * Created by PengHongfu 
 */
public class HelloJob implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //編寫具體的業務邏輯
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        System.out.println("Hello World! Current time is:" + sf.format(calendar.getTime()));
    }
}

HelloScheduler.java

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

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * Created by PengHongfu
 */
public class HelloScheduler {
    public static void main(String args[]) throws SchedulerException {
        //建立一個JobDetail例項，將該例項與HelloJob class 繫結
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myJob", "group1").build();

        //建立一個Trigger例項，定義該job立即執行，並且每隔兩秒重複執行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())
                .build();
        //建立Schedule例項
        SchedulerFactory sfat = new StdSchedulerFactory();
        Scheduler scheduler = sfat.getScheduler();
        scheduler.start();
        //列印當前時間
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current time is:" + sf.format(calendar.getTime()));
        scheduler.scheduleJob(jobDetail, trigger);
    }

}

Current time is:2018-09-13 11:57:36

Hello World! Current time is:2018-09-13 11:57:36

Hello World! Current time is:2018-09-13 11:57:38

Hello World! Current time is:2018-09-13 11:57:40

Hello World! Current time is:2018-09-13 11:57:42

Hello World! Current time is:2018-09-13 11:57:44
....

Job&JobDetail

Job

實現業務邏輯的任務介面


package org.quartz;

public interface Job {
    void execute(JobExecutionContext var1) throws JobExecutionException;
}

這裡寫圖片描述

獲取jobDetail的各種引數

public class HelloScheduler {
    public static void main(String args[]) throws SchedulerException {
        //建立一個JobDetail例項，將該例項與HelloJob class 繫結
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myJob", "group1").build();
        System.out.println("jobDetail's name:"+jobDetail.getKey().getName());
        System.out.println("jobDetail's group:"+jobDetail.getKey().getGroup());
        System.out.println("jobDetail's jobClass:"+jobDetail.getKey().getClass());

        //建立一個Trigger例項，定義該job立即執行，並且每隔兩秒重複執行一次
        Trigger trigger = TriggerBuilder.newTrigger()
.....

JobExecutionContext&JobDataMap

這裡寫圖片描述

HelloJob1.java

import org.quartz.*;

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * 實現業務邏輯的介面
 * Created by PengHongfu 
 */
public class HelloJob1 implements Job {
    private String message;
    private Float floatJobValue;
    private Double doubleTriggerValue;
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //編寫具體的業務邏輯
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        //System.out.println(sf.format(calendar.getTime())+":Hello World!");
        JobKey key = jobExecutionContext.getJobDetail().getKey();
        System.out.println("my Name and group are:"+key.getName()+","+key.getGroup());
        TriggerKey triggerKey = jobExecutionContext.getTrigger().getKey();
        System.out.println("My trigger name and group are:"+triggerKey.getName()
                +";"+triggerKey.getGroup());

        JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        JobDataMap tdataMap = jobExecutionContext.getTrigger().getJobDataMap();
        String jobMsg = (String) dataMap.get("message");
        Float jobFloatValue = (Float) dataMap.get("floatJobValue");
        String jobMsg1 = (String) tdataMap.get("message");
        Double jobFloatValue2 = (Double) tdataMap.get("doubleTriggerValue");
        System.out.println(jobMsg+","+jobFloatValue+","+jobMsg1+","+jobFloatValue2);


        //JobDataMap mergedJobDataMapd = jobExecutionContext.getMergedJobDataMap();

        System.out.println(message+", "+floatJobValue+" ,"+doubleTriggerValue);
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Float getFloatJobValue() {
        return floatJobValue;
    }

    public void setFloatJobValue(Float floatJobValue) {
        this.floatJobValue = floatJobValue;
    }

    public Double getDoubleTriggerValue() {
        return doubleTriggerValue;
    }

    public void setDoubleTriggerValue(Double doubleTriggerValue) {
        this.doubleTriggerValue = doubleTriggerValue;
    }
}

HelloScheduler1.java

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

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * Created by PengHongfu
 */
public class HelloScheduler1 {
    public static void main(String args[]) throws SchedulerException {
        //建立一個JobDetail例項，將該例項與HelloJob class 繫結
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myJob", "group1")
                .usingJobData("message","hello myJob1")
                .usingJobData("floatJobValue",3.14F).build();
        //建立一個Trigger例項，定義該job立即執行，並且每隔兩秒重複執行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .usingJobData("message","hello myTrigger1")
                .usingJobData("doubleTriggerValue",2.0D)
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())
                .build();
        //建立Schedule例項
        SchedulerFactory sfat = new StdSchedulerFactory();
        Scheduler scheduler = sfat.getScheduler();
        scheduler.start();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        System.out.println("Current time is："+sf.format(calendar.getTime()));
        scheduler.scheduleJob(jobDetail,trigger);
    }
}

Current time is：2018-09-13 16:01:21

2018-09-13 16:01:21:Hello World!
my Name and group are:myJob,group1
My trigger name and group are:myTrigger;group1
hello myJob1,3.14,hello myTrigger1,2.0
hello myTrigger1, 3.14 ,2.0

2018-09-13 16:01:23:Hello World!
my Name and group are:myJob,group1
My trigger name and group are:myTrigger;group1
hello myJob1,3.14,hello myTrigger1,2.0
hello myTrigger1, 3.14 ,2.0

Trigger

Quartz中的觸發器用來告訴排程程式作業什麼時候觸發。
即Trigger物件是用來觸發執行Job的。

JobKey

表示job例項的標識，觸發器被觸發時，該指定的job例項會執行。

StartTime
EndTime

HelloScheduler2.java

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

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * Created by PengHongfu 2018-09-07 10:04
 */
public class HelloScheduler2 {
    public static void main(String args[]) throws SchedulerException {
        //建立一個JobDetail例項，將該例項與HelloJob class 繫結
        JobDetail jobDetail = JobBuilder.newJob(HelloJob2.class)
                .withIdentity("myJob").build();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        Calendar endCalendar = Calendar.getInstance();
        System.out.println("Current time is：" + sf.format(calendar.getTime()));
        calendar.add(Calendar.SECOND, 3);
        endCalendar.add(Calendar.SECOND, 6);//結束時間6秒之後
        //建立一個Trigger例項，定義該job立即執行，並且每隔兩秒重複執行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startAt(calendar.getTime())
                .endAt(endCalendar.getTime())
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())
                .build();
        //建立Schedule例項
        SchedulerFactory sfat = new StdSchedulerFactory();
        Scheduler scheduler = sfat.getScheduler();
        scheduler.start();

        scheduler.scheduleJob(jobDetail, trigger);
    }
}

HelloJob2.java

import org.quartz.*;

import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * 實現業務邏輯的介面
 * Created by PengHongfu 2018-09-07 10:00
 */
public class HelloJob2 implements Job {
    private String message;
    private Float floatJobValue;
    private Double doubleTriggerValue;
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //編寫具體的業務邏輯
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        System.out.println("Current time is:"+sf.format(calendar.getTime()));
        Trigger currTrigger = jobExecutionContext.getTrigger();
        System.out.println("Start time is:"+currTrigger.getStartTime());
        System.out.println("End time is:"+currTrigger.getEndTime());

        JobKey jobKey = currTrigger.getJobKey();
        System.out.println("JobKey info---"+"jobName:"
                +jobKey.getName()+" jobGroup"+jobKey.getGroup());
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Float getFloatJobValue() {
        return floatJobValue;
    }

    public void setFloatJobValue(Float floatJobValue) {
        this.floatJobValue = floatJobValue;
    }

    public Double getDoubleTriggerValue() {
        return doubleTriggerValue;
    }

    public void setDoubleTriggerValue(Double doubleTriggerValue) {
        this.doubleTriggerValue = doubleTriggerValue;
    }
}

Current time is：2018-09-13 16:56:20

Current time is:2018-09-13 16:56:23
Start time is:Thu Sep 13 16:56:23 CST 2018
End time is:Thu Sep 13 16:56:26 CST 2018
JobKey info---jobName:myJob jobGroupDEFAULT

Current time is:2018-09-13 16:56:25
Start time is:Thu Sep 13 16:56:23 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    Java定時任務Timer和Quartz
      
							
							
							定時任務排程



基於給定的時間點，給定的時間間隔或者給定的執行次數自動執行的任務



定時任務工具

 
Timer
Quartz 


  Timer能完成一些簡單的定時任務，能實現具體某個時間執行任務。只有一個後臺執行定時任務。 
  Quartz能實 

  
 

    

    
    定時器的實現、java定時器Timer和Quartz介紹與Spring中定時器的配置
      
欄位 允許值 允許的特殊字元   
秒 0-59 , - * /   
分 0-59 , - * /   
小時 0-23 , - * /   
日期 1-31 , - * ? / L W C   
月份 1-12 或者 JAN-DEC , - * /   
星期 1-7 或者 SUN-SAT , - *  

  
 

    

    
    Java定時任務Timer排程器【一】 原始碼分析（圖文詳解版）
       
 
 就以鬧鐘的例子開頭吧（後續小節皆以鬧鐘為例，所有原始碼只列關鍵部分）。 
 public class ScheduleDemo {
 
    public static void main(String[] args) throws InterruptedException {
       

  
 

    

    
    Java定時任務Timer排程器【二】 多執行緒原始碼分析（圖文版）
       
 
   
 上一節通過一個小例子分析了Timer執行過程，牽涉的執行執行緒雖然只有兩個，但實際場景會比上面複雜一些。 
  
 首先通過一張簡單類圖（只列出簡單的依賴關係）看一下Timer暴露的介面。 
   
 為了演示Timer所暴露的介面，下面舉一個極端的例子（每一個介面方法面 

  
 

    

    
    Java定時任務Timer排程器【三】 注意事項（任務精確性與記憶體洩漏）
       
 
 一、任務精確性 
 通過前兩節的分析，大概知道了Timer的執行原理，下面說說使用Timer需要注意的一些事項。下面是Timer簡單原理圖 
  
 從上圖可以看到，真正執行鬧鐘的是一個單執行緒。也就是說佇列中的鬧鐘，只能依次進行序列化的操作，鬧鐘的定時執行得不到保證。 
 比如下面的例子（本節所有 

  
 

    

    
    JAVA定時任務——Timer
       
 
  
  開發中需要使用定時器，搜尋到一篇還不錯的解析，轉載過來。 
  
 在我們程式設計過程中如果需要執行一些簡單的定時任務，無須做複雜的控制，我們可以考慮使用JDK中的Timer定時任務來實現。下面LZ就其原理、例項以及Timer缺陷三個方面來解析java Timer定時器。 
  
  一、簡 

  
 

    

    
    java-定時任務排程工具Timer/Quartz|springboot整合定時排程
      
								
								            
							
							
							什麼是定時任務排程
定時任務排程：基於給定的時間點，給定的時間間隔或者給定的執行次數自動執行任務。
兩種java定時任務排程工具卻別




Timer
Quartz




小弟!功能簡單,開銷小
大 

  
 

    

    
    Java定時任務的幾種方法（Thread 和 Timer,執行緒池）
      
								
								            
						
                

/** 
 * 普通thread 
 * 這是最常見的，建立一個thread，然後讓它在while迴圈裡一直執行著， 
 * 通過sleep方法來達到定時任務的效果。這樣可以快速簡單的實現，程式碼如 

  
 

    

    
    java多執行緒與高併發庫應用（二）執行緒建立和定時任務Timer
      
							
							
							1、建立執行緒的兩種方式， 
通過start， 
執行run方法。 

第一種實現runnable， 
定義類實現Runnable介面 
重寫Runnable介面中的run方法 
通過Thread建立執行緒物件 
將Runnable介面的子類物件作為實際引數傳遞 

  
 

    

    
    [譯]Java定時任務排程-Quartz文件（三）進一步講講Job和Job Detail
      
							
							
							正如上篇文章所說的，Job很容易實現，只需要介面中唯一的execute方法。除此之外，你還需要稍微瞭解下Job、execute、Job interface和JobDetail的一些東西。

當你寫的Job類執行特定任務時，Quartz需要知道這個類應該具有的各種 

  
 

    

    
    Java定時任務：利用java Timer類實現定時執行任務的功能
      lpad   虛擬   觀察   exce   就是   set   ring   構造   trac   一、概述
在java中實現定時執行任務的功能，主要用到兩個類，Timer和TimerTask類。其中Timer是用來在一個後臺線程按指定的計劃來執行指定的任務。
TimerTask一個抽象類，它的子類代 

  
 

    

    
    Java定時任務工具詳解之Timer篇
      java   定時任務   定時   任務調度   什麽   出身   需要   bsp   機制   Java定時任務調度工具詳解
什麽是定時任務調度？
◆ 基於給定的時間點，給定的時間間隔或者給定的執行次數自動執行的任務。
在Java中的定時調度工具？
◆ Timer       ◆Quartz
Time 

  
 

    

    
    atititt java定時任務框架選型Spring Quartz 註解總結
       
  
  
 分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow
 
 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！
 
 
          

  
 

    

    
    【小家java】Java定時任務ScheduledThreadPoolExecutor詳解以及與Timer、TimerTask的區別
       
 
  
  
 相關閱讀 
 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9 

  
 

    

    
    Java定時任務排程工具Timer詳解
       
 
 
 做專案很多時候會用到定時任務，比如在深夜，流量較小的時候，做一些統計工作。早上定時傳送郵件，更新資料庫等。 
 這裡可以用Java的Timer或執行緒池實現。 
 Timer可以實現，不過Timer存在一些問題。他起一個單執行緒，如果有異常產生，執行緒將退出，整個定時任務就失敗。 
 Timer 

  
 

    

    
    java定時任務 Quartz時間配置
       java Quartz定時器任務與Spring task定時的幾種實現 
基於java 的定時任務實現， 
Quartz 時間詳細配置    請查閱   http://www.cnblogs.com/sihuanian/p/5010872.html 

  
 

    

    
    Quartz cron 表示式(linux 定時器，java 定時任務，spring task定時任務)
      原文地址：https://blog.csdn.net/feng27156/article/details/39293403 
Quartz cron 表示式的格式十分類似於 UNIX cron 格式，但還是有少許明顯的區別。區別之一就是 Quartz 的格式向下支援到秒級別的計劃，而 UNIX cron 計劃 

  
 

    

    
    簡單介紹java原生的定時任務，和Jsoup工具包
      
							
							
							java原生定時任務建立，以及簡單jsoup的使用
package com.bzu.csh;

import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

im 

  
 

    

    
    Quartz使用-入門使用(java定時任務實現)
       
 
  
  
 Quartz是一個大名鼎鼎的Java版開源定時排程器，功能強悍，使用方便。 
  
  一、核心概念 
  
  Quartz的原理不是很複雜，只要搞明白幾個概念，然後知道如何去啟動和關閉一個排程程式即可。

1、Job
表示一個工作，要執行的具體內容。此介面中只有一個方法
void e 

  
 

    

    
    Java 定時任務執行(一):定時器 Timer 的使用.
       
 
 https://www.ibm.com/developerworks/cn/java/j-lo-taskschedule/ 
   
 閱讀目錄 
 
  一、概念 
  二、Timer類注意事項 
  三、scheduleAtFixedRate(TimerTask task,Date f

Java定時任務Timer和Quartz

定時任務排程

定時任務工具

Timer

程式碼例項

Timer的定時排程函式

`schedule()、scheduleAtFixedRate()`

`cancel()`方法

`scheduledExecutionTime()`方法

schedule和scheduleAtFixedRate的區別

Timer函式的綜合運用

Timer的缺陷

Quartz

Quartz例項

Job&JobDetail

JobExecutionContext&JobDataMap

Trigger

Java定時任務Timer和Quartz

定時器的實現、java定時器Timer和Quartz介紹與Spring中定時器的配置

Java定時任務Timer排程器【一】原始碼分析（圖文詳解版）

Java定時任務Timer排程器【二】多執行緒原始碼分析（圖文版）

Java定時任務Timer排程器【三】注意事項（任務精確性與記憶體洩漏）

JAVA定時任務——Timer

java-定時任務排程工具Timer/Quartz|springboot整合定時排程

Java定時任務的幾種方法（Thread 和 Timer,執行緒池）

java多執行緒與高併發庫應用（二）執行緒建立和定時任務Timer

[譯]Java定時任務排程-Quartz文件（三）進一步講講Job和Job Detail

Java定時任務：利用java Timer類實現定時執行任務的功能

Java定時任務工具詳解之Timer篇

atititt java定時任務框架選型Spring Quartz 註解總結

【小家java】Java定時任務ScheduledThreadPoolExecutor詳解以及與Timer、TimerTask的區別

Java定時任務排程工具Timer詳解

java定時任務 Quartz時間配置

Quartz cron 表示式(linux 定時器，java 定時任務，spring task定時任務)

簡單介紹java原生的定時任務，和Jsoup工具包

Quartz使用-入門使用(java定時任務實現)

Java 定時任務執行(一):定時器 Timer 的使用.

Java定時任務Timer和Quartz

定時任務排程

定時任務工具

Timer

程式碼例項

Timer的定時排程函式

schedule()、scheduleAtFixedRate()

cancel()方法

scheduledExecutionTime()方法

schedule和scheduleAtFixedRate的區別

Timer函式的綜合運用

Timer的缺陷

Quartz

Quartz例項

Job&JobDetail

JobExecutionContext&JobDataMap

Trigger

相關推薦

`schedule()、scheduleAtFixedRate()`

`cancel()`方法

`scheduledExecutionTime()`方法