java定时器初探

最新推荐文章于 2023-03-13 16:41:50 发布

舞枫人

最新推荐文章于 2023-03-13 16:41:50 发布

阅读量398

点赞数

分类专栏：笔记文章标签： java 定时器 timer scheduled

本文链接：https://blog.youkuaiyun.com/li575098618/article/details/49785987

版权

笔记专栏收录该内容

75 篇文章

订阅专栏

本文探讨了Java中Timer类存在的问题及解决方案，通过对比Timer与ScheduledExecutorService的使用，展示了如何避免线程竞争和任务中断的问题。重点介绍了如何利用ScheduledExecutorService实现更灵活、高效的定时任务调度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

从《thinking in java》了解到java原生的Times类有两个问题：
（1）Timer是启动单个线程来处理所有的时间任务，如果一个任务耗时很久，那么如果在执行这个过程中，下个定时任务开始，就会对接下来的任务造成影响；
（2）Timer某一个定时程序在执行过程中抛出运行时异常，那么定时器就会以为终止定时器的运行；

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

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

public class Timer {  

    private TaskQueue queue = new TaskQueue();  

    private TimerThread thread = new TimerThread(queue);  

    。。。。。。

写代码验证一下，看看是否是这样的。
Timer和TimeTask是java基础中实现定时程序的两个核心类。
A、TimerTask是一个抽象类，内部实现了Runnable接口，同时定义了任务的几个状态；
B、Timer类来负责调度继承TimerTask的具体任务，可是实现定时或者指定周期运行

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

public class TimerTest extends TimerTask{  

    public static void main(String[] args) {  
        Timer timer1 = new Timer("time1");  

        timer1.schedule(new TimerTest(), 1);  
        timer1.schedule(new TimerTest(), 2);  
        timer1.schedule(new TimerTest(), 3);  
    }  

    @Override  
    public void run() {  
        try {  
            System.out.println(Thread.currentThread().getName()+"-线程暂停5秒");  
            TimeUnit.SECONDS.sleep(5);  
            System.out.println(Thread.currentThread().getName()+"-线程执行结束");  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  

}

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

public class TimerTest extends TimerTask{  

    public static void main(String[] args) {  
        Timer timer1 = new Timer("time1");        
        timer1.schedule(new TimerTest(), 1);  
        timer1.schedule(new TimerTest(), 2);  
    }  

    @Override  
    public void run() {  
        try {  
            System.out.println(Thread.currentThread().getName()+"-线程暂停5秒");  
            TimeUnit.SECONDS.sleep(5);  
            System.out.println(Thread.currentThread().getName()+"-线程执行结束");  
            String aaa = null;  
            System.out.println(aaa.hashCode());  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  

}

Timer有三部分组成：
任务单元，任务队列，任务调度器，从下图能够非常直观的看出几个类直接的关系。
这里写图片描述
TaskQueue任务队列的管理：

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

void add(TimerTask task) {  
    if (size + 1 == queue.length)  
 queue = Arrays.copyOf(queue, 2*queue.length);  
   <span style="white-space: pre;"> </span>    queue[++size] = task;  
    fixUp(size);  
}

上面是TaskQueue中的add方法，添加新的TimeTask的时候，首先判断是否超出了数组长度，初始数组是128，如果超过，就将数组长度加倍。
最后执行fixUp，重新将数组进行排序，TimeTask中nextExecutionTime小的排在数组的最前面，即最近一个要执行的定时任务。

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

private void sched(TimerTask task, long time, long period) {  
        if (time < 0)  
            throw new IllegalArgumentException("Illegal execution time.");  

        synchronized(queue) {  
            if (!thread.newTasksMayBeScheduled)  
                throw new IllegalStateException("Timer already cancelled.");  

            synchronized(task.lock) {  
                if (task.state != TimerTask.VIRGIN)  
                    throw new IllegalStateException(  
                        "Task already scheduled or cancelled");  
                task.nextExecutionTime = time;  
                task.period = period;  
                task.state = TimerTask.SCHEDULED;  
            }  

            queue.add(task);  
            if (queue.getMin() == task)  
                queue.notify();  
        }  
    }

从上述代码中可以看出，首先锁住任务队列，如果task符合条件，则直接将任务加入到任务队列中，并设置好任务下次执行时间以及执行周期并设置状态为可以被调度。
这里写图片描述
鉴于 Timer 的上述缺陷，Java 5 推出了基于线程池设计的 ScheduledExecutor。其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。

java.util.courrent包中有一个定时调度线程的类：ScheduledExecutorService
下面的这个例子，从执行结果来看，两个定时程序是并发执行的，并且一个定时程序执行如果抛出异常，对于下个任务的执行没有啥影响，照样执行下去。

public class CourrentTimer implements Runnable {
public static void main(String[] args) {  
    CourrentTimer timer = new CourrentTimer();  
    ScheduledExecutorService executer = Executors.newScheduledThreadPool(2);  
               //创建线程池，调用ThreadPoolExecutor来进行创建，通过BlockingQueue来管理任务队列  
    executer.submit(timer);  
    executer.submit(timer);  
               //Timer类实现Runnable接口，从而进入任务队列  
}  
@Override  
public void run() {  
    try {  
        TimeUnit.SECONDS.sleep(5);  
        System.out.println(Thread.currentThread().getName()+"-线程暂停5秒后运行-"+new Date());  
        String aa = null;  
        System.out.println(aa.hashCode());  
    } catch (Exception e) {  
        e.printStackTrace();  
    }                 
}

下面是执行返回的结果

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将定时程序作了一个很好的封装，使开发者通过简单的配置就可以实现定时程序的调度。