了解了一下Java实现简单定时任务的三种方式，分别做了个例子。
自己写篇以记录、备忘。
注释都清楚了，不另外解释。
方式一：
package test.timertask;
/**
* 使用Thread.sleep的方式来实现
* 这种方式完全是自己实现的，该控制的地方控制，怎么写都可以
* @author wz
*/
public class MyTimerTask {
public static void main(String[] args) {
MyTimerTask mt = new MyTimerTask();
mt.task();
}
public void task(){
final long timeInterval = 1000;
(new Runnable() {
public void run() {
while (true) {
// 执行任务
System.out.println("do the task……");
try {
Thread.sleep(timeInterval);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).run();
//这里直接调runnable的run方法了，这样是由main方法的执行线程直接转去执行这个runnable了（同一个线程）
//当然也可new一个Thread，将runnable扔进去后调用其start方法（另启一线程）
}
}
方式二：
package test.timertask;
import java.util.Timer;
import java.util.TimerTask;
/**
*
* @author wz
* 通过Timer和TimerTask来实现，jdk自己实现且封装了其操作，
* TimerTask实现Runnable接口，但是其实现正是留给用户制定任务的接口
* 然后通过Timer来执行即可，Timer另启线程来执行任务，且实现了线程同步的，所示线程安全的
* Timer维持一个任务队列，可以调度多个任务
*
*/
public class MyTimerTask2 {
public static void main(String[] args) {
MyTimerTask2 mt2 =new MyTimerTask2();
mt2.task();
}
public void task(){
//制定一个任务
TimerTask task = new TimerTask() {
@Override
public void run() {
System.out.println("执行任务ing");
}
};
//task - 所要安排的任务。
//delay - 执行任务前的延迟时间，单位是毫秒。
//period - 执行各后续任务之间的时间间隔，单位是毫秒。
Timer timer = new Timer();
long delay = 0;
long intevalPeriod = 1 * 1000;
timer.scheduleAtFixedRate(task, delay, intevalPeriod);
}
}
方式三：
package test.timertask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
/**
*
* @author wz
* jdk1.5提供了支持并发的定时任务处理工具ScheduledExecutorService
* 1.以线程池的方式来执行任务，效率高了
* 2.可以设置开始延迟时间和任务取消时间
*
*/
public class MyTimerTask3 {
public static void main(String[] args) {
MyTimerTask3 mtt = new MyTimerTask3();
mtt.taskForAPeriod();
}
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
public void taskForAPeriod() {
//定义一个任务
final Runnable task = new Runnable() {
public void run() {
System.out.println("执行任务");
}
};
//scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit):
//通过ScheduledExecutorService的scheduleAtFixedRate来执行任务
//参数
//command - 要执行的任务
//initialDelay - 首次执行的延迟时间
//period - 连续执行之间的周期
//unit - initialDelay 和 period 参数的时间单位
final ScheduledFuture<?> taskHandle = scheduler.scheduleAtFixedRate(task, 1, 1, TimeUnit.SECONDS);
//schedule(Runnable command,long delay,TimeUnit unit)创建并执行在给定延迟后启用的一次性操作。 （取消任务本身也是一个任务，一次去下就OK）
//参数：
//command - 要执行的任务
//delay - 从现在开始延迟执行的时间
//unit - 延迟参数的时间单位
scheduler.schedule(new Runnable() {
public void run() {
taskHandle.cancel(true);//取消任务
}
}, 10, TimeUnit.SECONDS);//在10个TimeUnit.SECONDS时间单位后
}
}