【转载】Java定时器的学习

前几看了一下《thinking in java》了解到java原生的Times类有两个问题：

（1）Timer是启动单个线程来处理所有的时间任务，如果一个任务耗时很久，那么如果在执行这个过程中，下个定时任务开始，就会对接下来的任务造成影响；

（2）Timer某一个定时程序在执行过程中抛出运行时异常，那么定时器就会以为终止定时器的运行；

首先了解一下Timer类的核心组成

Timer有两个核心的属性，一个是TaskQueue对象，用于存储任务队列，一个是TimerThread，用于执行队列中的任务。

Java代码  收藏代码

  1. public class Timer {  

  2.   

  3.     private TaskQueue queue = new TaskQueue();  

  4.   

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

  6.   

  7.     。。。。。。  

写代码验证一下，看看是否是这样的。

Timer和TimeTask是java基础中实现定时程序的两个核心类。

A、TimerTask是一个抽象类，内部实现了Runnable接口，同时定义了任务的几个状态；

B、Timer类来负责调度继承TimerTask的具体任务，可是实现定时或者指定周期运行

通过打印可以发现，代码是顺序执行的，最简单的代码实现：

Java代码  收藏代码

  1. public class TimerTest extends TimerTask{  

  2.   

  3.     public static void main(String[] args) {  

  4.         Timer timer1 = new Timer("time1");  

  5.           

  6.         timer1.schedule(new TimerTest(), 1);  

  7.         timer1.schedule(new TimerTest(), 2);  

  8.         timer1.schedule(new TimerTest(), 3);  

  9.     }  

  10.   

  11.     @Override  

  12.     public void run() {  

  13.         try {  

  14.             System.out.println(Thread.currentThread().getName()+"-线程暂停5秒");  

  15.             TimeUnit.SECONDS.sleep(5);  

  16.             System.out.println(Thread.currentThread().getName()+"-线程执行结束");  

  17.         } catch (InterruptedException e) {  

  18.             e.printStackTrace();  

  19.         }  

  20.     }  

  21.   

  22. }  

  

当代码运行中，第一个任务出现NullPointException时，第二个任务就不会再运行下去。

Java代码  收藏代码

  1. public class TimerTest extends TimerTask{  

  2.   

  3.     public static void main(String[] args) {  

  4.         Timer timer1 = new Timer("time1");        

  5.         timer1.schedule(new TimerTest(), 1);  

  6.         timer1.schedule(new TimerTest(), 2);  

  7.     }  

  8.   

  9.     @Override  

  10.     public void run() {  

  11.         try {  

  12.             System.out.println(Thread.currentThread().getName()+"-线程暂停5秒");  

  13.             TimeUnit.SECONDS.sleep(5);  

  14.             System.out.println(Thread.currentThread().getName()+"-线程执行结束");  

  15.             String aaa = null;  

  16.             System.out.println(aaa.hashCode());  

  17.         } catch (InterruptedException e) {  

  18.             e.printStackTrace();  

  19.         }  

  20.     }  

  21.   

  22. }  

Timer有三部分组成：

任务单元，任务队列，任务调度器，从下图能够非常直观的看出几个类直接的关系。

TaskQueue任务队列的管理：

一个具有优先级的时间任务队列，通过下次执行时间来进行排序。实际上就是一个数组，数据里面放着了TimeTask对象。

Java代码  收藏代码

  1. void add(TimerTask task) {  

  2.     if (size + 1 == queue.length)  

  3.  queue = Arrays.copyOf(queue, 2*queue.length);  

  4.    <span style="white-space: pre;"> </span>    queue[++size] = task;  

  5.     fixUp(size);  

  6. }  

 上面是TaskQueue中的add方法，添加新的TimeTask的时候，首先判断是否超出了数组长度，初始数组是128，如果超过，就将数组长度加倍。

最后执行fixUp，重新将数组进行排序，TimeTask中nextExecutionTime小的排在数组的最前面，即最近一个要执行的定时任务。

Timer中重载了这个方法schedule，用来实现不同场景的任务调度，每一个schedule方法中都是用了这个方法sched

Java代码  收藏代码

  1. private void sched(TimerTask task, long time, long period) {  

  2.         if (time < 0)  

  3.             throw new IllegalArgumentException("Illegal execution time.");  

  4.   

  5.         synchronized(queue) {  

  6.             if (!thread.newTasksMayBeScheduled)  

  7.                 throw new IllegalStateException("Timer already cancelled.");  

  8.   

  9.             synchronized(task.lock) {  

  10.                 if (task.state != TimerTask.VIRGIN)  

  11.                     throw new IllegalStateException(  

  12.                         "Task already scheduled or cancelled");  

  13.                 task.nextExecutionTime = time;  

  14.                 task.period = period;  

  15.                 task.state = TimerTask.SCHEDULED;  

  16.             }  

  17.   

  18.             queue.add(task);  

  19.             if (queue.getMin() == task)  

  20.                 queue.notify();  

  21.         }  

  22.     }  

 从上述代码中可以看出，首先锁住任务队列，如果task符合条件，则直接将任务加入到任务队列中，并设置好任务下次执行时间以及执行周期并设置状态为可以被调度。

鉴于 Timer 的上述缺陷，Java 5 推出了基于线程池设计的 ScheduledExecutor。其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。

java.util.courrent包中有一个定时调度线程的类：ScheduledExecutorService

下面的这个例子，从执行结果来看，两个定时程序是并发执行的，并且一个定时程序执行如果抛出异常，对于下个任务的执行没有啥影响，照样执行下去。

Java代码  收藏代码

  1.   

public class CourrentTimer implements Runnable {

Java代码  收藏代码

  1. public static void main(String[] args) {  

  2.     CourrentTimer timer = new CourrentTimer();  

  3.     ScheduledExecutorService executer = Executors.newScheduledThreadPool(2);  

  4.                //创建线程池，调用ThreadPoolExecutor来进行创建，通过BlockingQueue来管理任务队列  

  5.     executer.submit(timer);  

  6.     executer.submit(timer);  

  7.                //Timer类实现Runnable接口，从而进入任务队列  

  8. }  

  9. @Override  

  10. public void run() {  

  11.     try {  

  12.         TimeUnit.SECONDS.sleep(5);  

  13.         System.out.println(Thread.currentThread().getName()+"-线程暂停5秒后运行-"+new Date());  

  14.         String aa = null;  

  15.         System.out.println(aa.hashCode());  

  16.     } catch (Exception e) {  

  17.         e.printStackTrace();  

  18.     }                 

  19. }  

 

 下面是执行返回的结果

pool-1-thread-1-线程暂停5秒后运行-Mon Feb 13 20:54:06 CST 2012
java.lang.NullPointerException
at CourrentTimer.run(CourrentTimer.java:24)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:441)
at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
at java.util.concurrent.FutureTask.run(FutureTask.java:138)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:98)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:206)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
pool-1-thread-2-线程暂停5秒后运行-Mon Feb 13 20:54:06 CST 2012
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
at java.lang.Thread.run(Thread.java:662)
java.lang.NullPointerException
at CourrentTimer.run(CourrentTimer.java:24)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:441)
at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
at java.util.concurrent.FutureTask.run(FutureTask.java:138)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:98)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:206)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
at java.lang.Thread.run(Thread.java:662)

java的Timer和TimerTask两个类以及java.util.courrent中的ScheduledExecutorService可是实现定时以及周期的执行，但是复杂的定时任务（例如每周二晚上0点到4点执行）就暂时无法满足，需要结果时间工具类，Spring quartz将定时程序作了一个很好的封装，使开发者通过简单的配置就可以实现定时程序的调度。

下面介绍几个Quartz的核心概念

 主要解决了一个问题：

定时任务调度器，调用什么任务，啥时候去调用。

1、Job
表示一个工作，要执行的具体内容。此接口中只有一个方法
void execute(JobExecutionContext context)

2、JobDetail
JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。

3、Trigger代表一个调度参数的配置，什么时候去调。

4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。

 

Java代码  收藏代码

  1. public interface Job {  

  2.    //在Trigger配置下通过scheduler来进行调度的具体任务  

  3.      

  4.     public void execute(JobExecutionContext context)  

  5.             throws JobExecutionException;  

  6.   

  7.      //任务的上下文对象，包含了任务执行细节中的各个情况  

  8. }  

Spring和Quartz的整合，可以通过简单扼配置，就能完成负责的时间调度任务，对于应用来说，只需要实现具体的任务即可，时间的调度等等细节交由Quartz来执行。

下面通过一个简单的例子来说明：

<!--
定义调用对象和调用对象的方法，这里定义了执行任务的bean以及bean中的方法
-->
<bean id="jobtask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetBeanName">
<value>executerInitCache</value>
</property>
<property name="targetMethod">
<value>load</value>
</property>
</bean>

<!-- 定义触发时间，相当于抽象了任务执行的规则，这个Trigger类需要具体的job以及关联这个job的时间规则 -->
<bean id="doTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="jobtask" />
</property>
<property name="cronExpression">
<value>0 30 2 * * ? *</value>
</property>
</bean>

<!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序 ，任务的调度器 -->
<bean id="startQuertz" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="doTime" />
</list>
</property>
</bean>

    timeTask俗称TT，是淘宝内部封装的一个时间调度器，Spring Quartz可以快速的完成时间的调度，但是如果应用是在集群环境下，我们就希望有一台机器来完成定时的任务，如果每台机器跑的代码完成一样，那么这个定时器就会在每台机器上都跑一边，如果跑的业务流程是幂等的还好，如果不是，那就会很多问题，TT能够实现的一个简单功能是，定时程序可以通过后台页面点击触发，能够制定集群中的一台机器来运行，具体原理介绍一下。

综合上面的一些结论，受到的一些启发：

（1）抽象任务接口，通过实现任务接口，来满足各种各样任务的需要，从而满足业务场景
（2）任务队列，存放实现任务接口的业务任务
（3）任务调度单独抽象，用来调度任务的执行
（4）抽象规则，定时任务有个规则就是定时程序啥时候执行，将这个设置抽象成一个简单的设置，通过一些表达式，来完成，简单高效

文章来源：http://iamzhongyong.iteye.com/blog/1404149

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/yeyuchangfeng/p/4436031.html