jdk实现定时与延迟

1. Timmer

JDK自带的任务调度工具,只需Timmer和TimmerTask两个类,就可以实现调度.

TimmerTask实现了Runnable接口,只需继承TimerTask并实现其中run方法,即可交于其自动调度

其调度方法是schedule(TimerTask task,long delay,long period)...

优点, JDK本身自带,无需第三方依赖,只需实现TimerTask

缺点, Timer中素有的任务都是一个TaskThread线程来调度执行,若前一个任务发生延迟会影响任务执行

2,ScheduledExecutorService

补充了Timmer缺陷,可以实现线程池的调度.多数情况使用此方法

scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimerUtil unit);

scheduleAtFixedRate方法是基于初始延迟(initialDelay)的,后固定间隔(period)进行任务调度,

scheduleWithFixedDelay(Runnable command,long initialDelay, long delay, TimeUnit unit);

scheduleWithFixedDelay方法是基于上次任务完成后固定的延迟时间来进行调度.

3,Quartz

在Spring框架中使用Quartz工具实现任务调度的方式

需要先定义任务配置,定义JobDetailFactoryBean,配置具体任务方法.然后定义TriggerFactoryBean,

配置具体任务方法的执行频率,

秒 分 时 日 月 年 --> ps: 0/1 * * * * ? 每秒执行一次 0 0/5 * * * ? 五分钟执行一次

最后定义SchedulerFactoryBean 注册需要执行的任务

当不需要多个线程同时去执行同一个任务时候 在JobDetailFactoryBean中配置

<property name="concurrent" value="false" />

 

Quartz和ScheduledThreadPoolExecutor一样,都是基于线程池调度的.

 

 

使用java.util.Timer类

package haiyang.yu.timer;

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

/**
 * Created on 2018-04-20 13:09
 * <p>Title:  haiyang.yu.timer</p>
 * <p>Description: </p>
 *
 * @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
 * @version 1.0
 */
public class TimedTask {

    private static void useTimerImplTimedTask(){

        // 第一个参数是任务，第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间，时间单位是毫秒
        new Timer().scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Local Time is " + new Date().toString());
            }
        },0L,1000L);
    }


    public static void main(String[] args) {
        useTimerImplTimedTask();
    }
}

使用java.util.concurrent.ScheduledExecutorService

package haiyang.yu.timer;

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

/**
 * Created on 2018-04-20 13:09
 * <p>Title:  haiyang.yu.timer</p>
 * <p>Description: </p>
 *
 * @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
 * @version 1.0
 */
public class TimedTask {

    private static void userScheduledExecutorServiceImplTiemdTask(){
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Local Time is " + new Date().toString());
            }
        };
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        // 第一个参数是任务，第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间,第四个参数是时间单位
        service.scheduleAtFixedRate(runnable, 0L, 1L, TimeUnit.SECONDS);
    }

    public static void main(String[] args) {
        userScheduledExecutorServiceImplTiemdTask();
    }
}

不建议使用这种方案，最好是自己去创建线程池。可以参考下面的实现方案。

使用java.util.concurrent.ScheduledThreadPoolExecutor结合org.apache.commons.lang3.concurrent.BasicThreadFactory（推荐使用）

package haiyang.yu.timer;

import org.apache.commons.lang3.concurrent.BasicThreadFactory;

import java.util.Date;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created on 2018-04-20 13:09
 * <p>Title:  haiyang.yu.timer</p>
 * <p>
     使用这种方案，需要引入common-lang3的jar包
     <dependency>
         <groupId>org.apache.commons</groupId>
         <artifactId>commons-lang3</artifactId>
         <version>3.6</version>
     </dependency>
 * </p>
 *
 * @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
 * @version 1.0
 */
public class TimedTask {

    private static void useScheduledThreadPoolExecutorImplTimedTask(){
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(
                1, new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(false).build());
        // 第一个参数是任务，第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间,第四个参数是时间单位
        scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("Local Time is " + new Date().toString());
            }
        }, 0L, 1L, TimeUnit.SECONDS);
    }

    public static void main(String[] args) {
        useScheduledThreadPoolExecutorImplTimedTask();
    }
}

使用java.lang.Thread

package haiyang.yu.timer;

import java.util.Date;

/**
 * Created on 2018-04-20 13:09
 * <p>Title:  haiyang.yu.timer</p>
 * <p>Description: </p>
 *
 * @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
 * @version 1.0
 */
public class TimedTask {

    private static void useThreadImplTimedTask(){

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    
                    System.out.println("Local Time is " + new Date().toString());
                    
                    try {
                        //时间间隔，单位是毫秒
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        
        Thread thread = new Thread(runnable);
        thread.start();

    }

    public static void main(String[] args) {
        useThreadImplTimedTask();
    }
}

这种方式使用的最多，但也是最lower的。

 

用ScheduledExecutorService是从的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。

1.相比于Timer的单线程，它是通过线程池的方式来执行任务的。

2.可以很灵活的去设定第一次执行任务delay时间。

3.提供了良好的约定，以便设定执行的时间间隔。