使用ScheduledThreadPoolExecutor代替Timer&TimerTask

TimerTaskTimerScheduledThreadPoolExecutor定时器 .
        如果我们想要延迟(deferred)或者周期性(periodic)执行一个任务，我们可以使用Java API 的Timer和TimerTask类。

        一般步骤是：

               继承TimerTask(抽象类)，复写run方法，方法体里代表需要执行的任务。

               实例化Timer（可以通过构造方法设置为守护线程），调用schedule的一个重载方法实现延迟或者周期性执行自定义任务。

       下面的例子演示了程序启动5秒后每隔1秒警报器叫一声，10次后终止程序执行。

Java代码 
1.import java.awt.Toolkit;  
2.import java.util.Timer;  
3.import java.util.TimerTask;  
4. 
5./** 
6. * 自定义Timer类 
7. *  
8. */ 
9.class BeepTimer extends TimerTask {  
10. 
11.    private Toolkit toolKit;  
12. 
13.    private int count;  
14. 
15.    public BeepTimer() {  
16.        toolKit = Toolkit.getDefaultToolkit();  
17.    }  
18. 
19.    @Override 
20.    public void run() {  
21.        if (count == 10)  
22.            System.exit(1);  
23.        toolKit.beep();  
24.        count++;  
25.    }  
26. 
27.}  
28. 
29.public class TimerDemo {  
30. 
31.    public static void main(String... args) {  
32. 
33.        BeepTimer bt = new BeepTimer(); //非守护线程  
34.        Timer timer = new Timer();  
35. 
36.        timer.schedule(bt, 5 * 1000, 1 * 1000); // 5秒后开始鸣叫，鸣叫10次，每次相隔1秒钟  
37.    }  
38. 
39.} 
import java.awt.Toolkit;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 自定义Timer类
 *
 */
class BeepTimer extends TimerTask {

 private Toolkit toolKit;

 private int count;

 public BeepTimer() {
  toolKit = Toolkit.getDefaultToolkit();
 }

 @Override
 public void run() {
  if (count == 10)
   System.exit(1);
  toolKit.beep();
  count++;
 }

}

public class TimerDemo {

 public static void main(String... args) {

  BeepTimer bt = new BeepTimer(); //非守护线程
  Timer timer = new Timer();

  timer.schedule(bt, 5 * 1000, 1 * 1000); // 5秒后开始鸣叫，鸣叫10次，每次相隔1秒钟
 }

}

    但是Timer和TimerTask存在一些缺陷：

        1：Timer只创建了一个线程。当你的任务执行的时间超过设置的延时时间将会产生一些问题。

        2：Timer创建的线程没有处理异常，因此一旦抛出非受检异常，该线程会立即终止。

 

    JDK 5.0以后推荐使用ScheduledThreadPoolExecutor。该类属于Executor Framework，它除了能处理异常外，还可以创建多个线程解决上面的问题。

        下面利用ScheduledThradPoolExecutor实现同一个功能。

Java代码 
1.import java.awt.Toolkit;  
2.import java.util.concurrent.ScheduledThreadPoolExecutor;  
3.import java.util.concurrent.TimeUnit;  
4. 
5.public class ExecutorDemo {  
6. 
7.    public static void main(String... args) {  
8.          
9.        ScheduledThreadPoolExecutor stpe = new ScheduledThreadPoolExecutor(10);  
10.        MyTask myTask = new MyTask();  
11.          
12.        stpe.scheduleWithFixedDelay(myTask, 5,1,TimeUnit.SECONDS);  
13.    }  
14. 
15.    private static class MyTask implements Runnable {  
16. 
17.        private Toolkit toolKit;  
18.        private int count;  
19.          
20.        public MyTask() {  
21.            toolKit = Toolkit.getDefaultToolkit();  
22.        }  
23.        @Override 
24.        public void run() {  
25.            if(count == 10) {  
26.                System.out.println("Termination!");  
27.                System.exit(1);  
28.            }  
29.            toolKit.beep();  
30.            System.out.println("Beep--------");  
31.            count++;  
32.        }  
33.    }  
34.}