使用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

*

Title: haiyang.yu.timer

*

Description:

*

* @author yuhaiyang

* @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

*

Title: haiyang.yu.timer

*

Description:

*

* @author yuhaiyang

* @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

*

Title: haiyang.yu.timer

*

使用这种方案，需要引入common-lang3的jar包

org.apache.commons

commons-lang3

3.6

*

*

* @author yuhaiyang

* @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

*

Title: haiyang.yu.timer

*

Description:

*

* @author yuhaiyang

* @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的。