Java实现定时任务的几种方案

使用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:[email protected]">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:[email protected]">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:[email protected]">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:[email protected]">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的。