使用ScheduledExecutorService代替下Timer
使用ScheduledExecutorService代替下Timer
1.scheduledExecutorService类方法scheduleAtFixedRate，ScheduleWithFixedDelay区别比较
1.1.ScheduleAtFixedRate 两次任务之间的间隔时间，取决于每次任务执行的时间长短；
假如每个任务执行花费time时间，如果time>= period，则这次任务执行结束后 立刻执行下一次任务。
如果time<period , 则这次任务执行结束后 ，隔 period-time后执行下一次任务。
1.2.ScheduleWithFixedDelay 不受任务执行时间长短影响，固定这次任务执行结束后隔x秒执行下一次.
不管任务花费多少时间，当这次任务执行结束，一定要等delay之后，再执行下一次任务。
package com.example.core.mydemo.timer; import java.util.Date; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * Timer不支持并发。 * * Timer不支持多线程。全部挂在Timer下的任务都是单线程的，任务仅仅能串行运行。假设当中一个任务运行时间过长。会影响到其它任务的运行，然后就可能会有各种接踵而来的问题。如果重开一个Timer？难道要为全部的耗时的Task都单开一个Timer。显然是不太可能。这样就太乱了。 * Timer的线程不捕获异常。TimerTask假设抛出异常，那么Timer唯一的进程就会挂掉，这样挂在Timer下的全部任务都会无法继续运行 * * 为了弥补Timer的缺陷，jdk1.5中引入了并发包。这里面提供的ScheduledExecutorService。详细实现类是：ScheduledThreadPoolExecutor。ScheduledThreadPoolExecutor支持多线程。同一时候在线程中对异常进行了捕获。所以是Timer的完美替换者。 * * 多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。 * */ public class TimerTest { private static ScheduledExecutorService scheduledExecutorService= Executors.newScheduledThreadPool(2); public static void main(String[] args) { scheduledExecutorService.submit(new Runnable() { @Override public void run() { System.out.println("scheduledExecutorService>>submit"); } }); scheduledExecutorService.execute(new Runnable() { @Override public void run() { System.out.println("scheduledExecutorService>>execute"); } }); //ScheduleAtFixedRate 两次任务之间的间隔时间，取决于每次任务执行的时间长短； /** * 假如每个任务执行花费time时间，如果time>= period，则这次任务执行结束后 立刻执行下一次任务。 * 如果time<period , 则这次任务执行结束后 ，隔 period-time后执行下一次任务。 * * * case1:Thread.sleep(3000); * -----------------scheduledExecutorService>>scheduleAtFixedRate------------------ * pool-1-thread-1begin == 1671768245503 * pool-1-thread-1end == 1671768248503 后4位，延时3秒 * ------------------scheduledExecutorService>>scheduleAtFixedRate------------------ * pool-1-thread-1begin == 1671768249503 后4位，等待4-3=1秒执行 * pool-1-thread-1end == 1671768252504 * *case2:Thread.sleep(5000); * ------------------scheduledExecutorService>>scheduleAtFixedRate------------------ * pool-1-thread-1begin == 1671768390045 * pool-1-thread-1end == 1671768395045 后4位，延时5秒 * ------------------scheduledExecutorService>>scheduleAtFixedRate------------------ * pool-1-thread-1begin == 1671768395045 后4位，立即执行 * pool-1-thread-1end == 1671768400045 */ scheduledExecutorService.scheduleAtFixedRate(new Runnable() { @Override public void run() { System.out.println("------------------scheduledExecutorService>>scheduleAtFixedRate------------------"); System.out.println(Thread.currentThread().getName() + "begin == " + System.currentTimeMillis()); try { Thread.sleep(5000); //任务花费大约3秒 >> 5000 立即执行 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "end == " + System.currentTimeMillis()); } },1,4, TimeUnit.SECONDS); //ScheduleWithFixedDelay 不受任务执行时间长短影响，固定这次任务执行结束后隔x秒执行下一次. //不管任务花费多少时间，当这次任务执行结束，一定要等delay之后，再执行下一次任务。 /** * case1:Thread.sleep(3000); * ------------------scheduledExecutorService>>scheduleWithFixedDelay------------------ * pool-1-thread-1begin == 1671768527054 * pool-1-thread-1end == 1671768530055 后4位，延时3秒 * ------------------scheduledExecutorService>>scheduleWithFixedDelay------------------ * pool-1-thread-1begin == 1671768534056 后4位，固定等待4秒执行 * pool-1-thread-1end == 1671768537056 * *case2:Thread.sleep(5000); * ------------------scheduledExecutorService>>scheduleWithFixedDelay------------------ * pool-1-thread-1begin == 1671768606672 * pool-1-thread-1end == 1671768611672 后4位，延时5秒 * ------------------scheduledExecutorService>>scheduleWithFixedDelay------------------ * pool-1-thread-1begin == 1671768615674 后4位，固定等待4秒执行 * pool-1-thread-1end == 1671768620674 */ scheduledExecutorService.scheduleWithFixedDelay(new Runnable() { @Override public void run() { System.out.println("------------------scheduledExecutorService>>scheduleWithFixedDelay------------------"); System.out.println(Thread.currentThread().getName() + "begin == " + System.currentTimeMillis()); try{ Thread.sleep(5000); //每个任务花费约3秒 >> 5000 仍然需要等待4秒执行 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "end == " + System.currentTimeMillis()); } },1,4, TimeUnit.SECONDS); TimerTask timerTask = new TimerTask(){ public void run(){ System.out.println("scheduledExecutorService>>schedule"); this.cancel();}}; //单次延时执行调度 scheduledExecutorService.schedule(timerTask,1,TimeUnit.SECONDS); //实例化Timer类 Timer timer=new Timer(); timer.schedule(new TimerTask(){ public void run(){ System.out.println("timer>>schedule"); this.cancel();}},1000); } }
2.ScheduledExecutorService与Timer的对比
Timer不支持并发。
Timer不支持多线程。全部挂在Timer下的任务都是单线程的，任务仅仅能串行运行。假设当中一个任务运行时间过长。会影响到其它任务的运行，然后就可能会有各种接踵而来的问题。如果重开一个Timer？难道要为全部的耗时的Task都单开一个Timer。显然是不太可能。这样就太乱了。
Timer的线程不捕获异常。TimerTask假设抛出异常，那么Timer唯一的进程就会挂掉，这样挂在Timer下的全部任务都会无法继续运行
为了弥补Timer的缺陷，jdk1.5中引入了并发包。这里面提供的ScheduledExecutorService。详细实现类是：ScheduledThreadPoolExecutor。ScheduledThreadPoolExecutor支持多线程。同一时候在线程中对异常进行了捕获。所以是Timer的完美替换者。
多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。
为什么需要代替Timer:
case1、Timer管理延时任务的缺陷
TimerThread是Thread的子类，可以看出内部只有一个线程
符合我们的预期结果。因为ScheduledThreadPool内部是个线程池，所以可以支持多个任务并发执行
case2、Timer当任务抛出异常时的缺陷
如果TimerTask抛出RuntimeException，Timer会停止所有任务的运行：
ScheduledExecutorService可以保证，task1出现异常时，不影响task2的运行
case3、Timer执行周期任务时依赖系统时间
Timer执行周期任务时依赖系统时间，如果当前系统时间发生变化会出现一些执行上的变化，ScheduledExecutorService基于时间的延迟，不会由于系统时间的改变发生执行变化。
package com.example.core.mydemo.timer; import java.util.Timer; import java.util.TimerTask; /** * TimerThread是Thread的子类，可以看出内部只有一个线程 * 定义了两个任务，预计是第一个任务1s后执行，第二个任务3s后执行，但是看运行结果： * task1 invoked ! 1000 * task2 invoked ! 4000 */ public class TimerTest2 { private static long start; public static void main(String[] args) throws Exception { TimerTask task1 = new TimerTask() { @Override public void run() { System.out.println("task1 invoked ! " + (System.currentTimeMillis() - start)); //case1 // try // { // Thread.sleep(3000); // } catch (InterruptedException e) // { // e.printStackTrace(); // } //case2 //如果TimerTask抛出RuntimeException，Timer会停止所有任务的运行： throw new RuntimeException(); } }; TimerTask task2 = new TimerTask() { @Override public void run() { System.out.println("task2 invoked ! " + (System.currentTimeMillis() - start)); } }; Timer timer = new Timer(); start = System.currentTimeMillis(); timer.schedule(task1, 1000); timer.schedule(task2, 3000); } }
package com.example.core.mydemo.timer; import java.util.TimerTask; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * * 符合我们的预期结果。因为ScheduledThreadPool内部是个线程池，所以可以支持多个任务并发执行 * task1 invoked ! 1003 * task2 invoked ! 3003 */ public class ScheduledThreadPoolExecutorTest { private static long start; public static void main(String[] args) { /** * 使用工厂方法初始化一个ScheduledThreadPool */ ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2); TimerTask task1 = new TimerTask() { @Override public void run() { System.out.println("task1 invoked ! " + (System.currentTimeMillis() - start)); //case1 // try // { // Thread.sleep(3000); // } catch (Exception e) // { // e.printStackTrace(); // } //case2 //ScheduledExecutorService可以保证，task1出现异常时，不影响task2的运行 throw new RuntimeException(); /** * case3 * Timer执行周期任务时依赖系统时间 * Timer执行周期任务时依赖系统时间，如果当前系统时间发生变化会出现一些执行上的变化，ScheduledExecutorService基于时间的延迟，不会由于系统时间的改变发生执行变化。 */ } }; TimerTask task2 = new TimerTask() { @Override public void run() { System.out.println("task2 invoked ! " + (System.currentTimeMillis() - start)); } }; start = System.currentTimeMillis(); newScheduledThreadPool.schedule(task1, 1000, TimeUnit.MILLISECONDS); newScheduledThreadPool.schedule(task2, 3000, TimeUnit.MILLISECONDS); } }
