1、Timer管理延时任务的缺陷

a、以前在项目中也经常使用定时器，比如每隔一段时间清理项目中的一些垃圾文件，每个一段时间进行数据清洗；然而Timer是存在一些缺陷的，因为Timer在执行定时任务时只会创建一个线程，所以如果存在多个任务，且任务时间过长，超过了两个任务的间隔时间，会发生一些缺陷：下面看例子：

Timer的源码：

1. public class Timer {

2. /**

3.     * The timer task queue.  This data structure is shared with the timer

4.     * thread.  The timer produces tasks, via its various schedule calls,

5.     * and the timer thread consumes, executing timer tasks as appropriate,

6.     * and removing them from the queue when they're obsolete.

7.     */

8. private TaskQueue queue = new TaskQueue();

9. 
   

10. /**

11.     * The timer thread.

12.     */

13. private TimerThread thread = new TimerThread(queue);

TimerThread是Thread的子类，可以看出内部只有一个线程。下面看个例子:

1. package com.zhy.concurrency.timer;

2. 
   

3. import java.util.Timer;

4. import java.util.TimerTask;

5. 
   

6. public class TimerTest

7. {

8. private static long start;

9. 
   

10. public static void main(String[] args) throws Exception

11. {

12. 
    

13. TimerTask task1 = new TimerTask()

14. {

15. @Override

16. public void run()

17. {

18. 
    

19. System.out.println("task1 invoked ! "

20. + (System.currentTimeMillis() - start));

21. try

22. {

23. Thread.sleep(3000);

24. } catch (InterruptedException e)

25. {

26. e.printStackTrace();

27. }

28. 
    

29. }

30. };

31. TimerTask task2 = new TimerTask()

32. {

33. @Override

34. public void run()

35. {

36. System.out.println("task2 invoked ! "

37. + (System.currentTimeMillis() - start));

38. }

39. };

40. Timer timer = new Timer();

41. start = System.currentTimeMillis();

42. timer.schedule(task1, 1000);

43. timer.schedule(task2, 3000);

44. 
    

45. }

46. }

定义了两个任务，预计是第一个任务1s后执行，第二个任务3s后执行，但是看运行结果：

1. task1 invoked ! 1000

2. task2 invoked ! 4000

task2实际上是4后才执行，正因为Timer内部是一个线程，而任务1所需的时间超过了两个任务间的间隔导致。下面使用ScheduledThreadPool解决这个问题：

1. package com.zhy.concurrency.timer;

2. 
   

3. import java.util.TimerTask;

4. import java.util.concurrent.Executors;

5. import java.util.concurrent.ScheduledExecutorService;

6. import java.util.concurrent.TimeUnit;

7. 
   

8. public class ScheduledThreadPoolExecutorTest

9. {

10. private static long start;

11. 
    

12. public static void main(String[] args)

13. {

14. /**

15. * 使用工厂方法初始化一个ScheduledThreadPool

16. */

17. ScheduledExecutorService newScheduledThreadPool = Executors

18. .newScheduledThreadPool(2);

19. 
    

20. TimerTask task1 = new TimerTask()

21. {

22. @Override

23. public void run()

24. {

25. try

26. {

27. 
    

28. System.out.println("task1 invoked ! "

29. + (System.currentTimeMillis() - start));

30. Thread.sleep(3000);

31. } catch (Exception e)

32. {

33. e.printStackTrace();

34. }

35. 
    

36. }

37. };

38. 
    

39. TimerTask task2 = new TimerTask()

40. {

41. @Override

42. public void run()

43. {

44. System.out.println("task2 invoked ! "

45. + (System.currentTimeMillis() - start));

46. }

47. };

48. start = System.currentTimeMillis();

49. newScheduledThreadPool.schedule(task1, 1000, TimeUnit.MILLISECONDS);

50. newScheduledThreadPool.schedule(task2, 3000, TimeUnit.MILLISECONDS);

51. }

52. }

输出结果：

<code class="language-java hljs" style="color:rgb(171,178,191);background-color:rgb(40,44,52);font-f