Timer与ExecutorService的比较

最新推荐文章于 2020-10-09 17:25:00 发布
最新推荐文章于 2020-10-09 17:25:00 发布
阅读量456 收藏 2
点赞数 1
分类专栏： java并发编程 文章标签： Timer ScheduledExecutorService Timer与ExecutorService比较
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37113604/article/details/89429986
版权

这里ExecutorService就不讲了，可以看下我之前的一篇博客：

https://blog.csdn.net/qq_37113604/article/details/89396015

首先看下Timer的使用：

Java中需要使用Timer与TimerTask两个类来配合完成定时任务。Timer是一种定时器工具，用来在一个后台线程计划执行指定任务，而TimerTask是一个抽象类，代表一个可以被Timer计划执行的任务。

Timer的构造方法们：

      在工具类Timer中，提供了四个构造方法，每个构造方法都启动了计时器线程，同时Timer类可以保证多个线程可以共享单个Timer对象而无需进行外部同步，所以Timer类是线程安全的。但是由于每一个Timer对象对应的是单个后台线程，用于顺序执行所有的计时器任务，一般情况下我们的线程任务执行所消耗的时间应该非常短，但是由于特殊情况导致某个定时器任务执行的时间太长，那么他就会“独占”计时器的任务执行线程，其后的所有线程都必须等待它执行完，这就会延迟后续任务的执行，使这些任务堆积在一起，具体情况我们后面分析。

      当程序初始化完成Timer后，定时任务就会按照我们设定的时间去执行，Timer提供了schedule方法，该方法有多中重载方式来适应不同的情况，如下：

      schedule(TimerTask task, Date time)：安排在指定的时间执行指定的任务。

      schedule(TimerTask task, Date firstTime, long period) ：安排指定的任务在指定的时间开始进行重复的固定延迟执行。

      schedule(TimerTask task, long delay) ：安排在指定延迟后执行指定的任务。

      schedule(TimerTask task, long delay, long period) ：安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

      同时也重载了scheduleAtFixedRate方法，scheduleAtFixedRate方法与schedule相同，只不过他们的侧重点不同，区别后面分析。

      scheduleAtFixedRate(TimerTask task, Date firstTime, long period)：安排指定的任务在指定的时间开始进行重复的固定速率执行。

      scheduleAtFixedRate(TimerTask task, long delay, long period)：安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

TimerTask的方法们：

 TimerTask类是一个抽象类，由Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()方法，该方法用于执行相应计时器任务要执行的操作。因此每一个具体的任务类都必须继承TimerTask，然后重写run()方法。

      另外它还有两个非抽象的方法：

      boolean cancel()：取消此计时器任务。

      long scheduledExecutionTime()：返回此任务最近实际执行的安排执行时间。

Timer的具体使用：

1.指定延迟时间执行定时任务

public class TimerTest01 {  
    Timer timer;  
    public TimerTest01(int time){  
        timer = new Timer();  
        timer.schedule(new TimerTaskTest01(), time * 1000);  
    }  
      
    public static void main(String[] args) {  
        System.out.println("timer begin....");  
        new TimerTest01(3);  
    }  
}  
  
public class TimerTaskTest01 extends TimerTask{  
  
    public void run() {  
        System.out.println("Time's up!!!!");  
    }  
}

打印结果：  Time up于3秒后打印

2.在指定时间执行定时任务

public class TimerTest02 {  
    Timer timer;  
      
    public TimerTest02(){  
        Date time = getTime();  
        System.out.println("指定时间time=" + time);  
        timer = new Timer();  
        timer.schedule(new TimerTaskTest02(), time);  
    }  
      
    public Date getTime(){  
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.HOUR_OF_DAY, 10);  
        calendar.set(Calendar.MINUTE, 29);  
        calendar.set(Calendar.SECOND, 00);  
        Date time = calendar.getTime();  
          
        return time;  
    }  
      
    public static void main(String[] args) {  
        new TimerTest02();  
    }  
}  
  
 class TimerTaskTest02 extends TimerTask{  
  
    @Override  
    public void run() {  
        System.out.println("指定时间执行线程任务...");  
    }  
}

执行结果：

3.延迟指定时间后以指定的间隔时间循环执行定时任务

public class TimerTest03 {  
    Timer timer;  
      
    public TimerTest03(){  
        timer = new Timer();  
        timer.schedule(new TimerTaskTest03(), 1000, 2000);  
    }  
      
    public static void main(String[] args) {  
        new TimerTest03();  
    }  
}  
  
public class TimerTaskTest03 extends TimerTask{  
  
    @Override  
    public void run() {  
        Date date = new Date(this.scheduledExecutionTime());  
        System.out.println("本次执行该线程的时间为：" + date);  
    }  
}

简单的演示了一下上面三个实例，同时也没有讲解scheduleAtFixedRate方法的例子，其实该方法与schedule方法一样。

4.分析schedule和scheduleAtFixedRate

      1、schedule(TimerTask task, Date time)、schedule(TimerTask task, long delay)

      对于这两个方法而言，如果指定的计划执行时间scheduledExecutionTime<= systemCurrentTime，则task会被立即执行。scheduledExecutionTime不会因为某一个task的过度执行而改变。

      2、schedule(TimerTask task, Date firstTime, long period)、schedule(TimerTask task, long delay, long period)

      这两个方法与上面两个就有点儿不同的，前面提过Timer的计时器任务会因为前一个任务执行时间较长而延时。在这两个方法中，每一次执行的task的计划时间会随着前一个task的实际时间而发生改变，也就是scheduledExecutionTime(n+1)=realExecutionTime(n)+periodTime。也就是说如果第n个task由于某种情况导致这次的执行时间过程，最后导致systemCurrentTime>= scheduledExecutionTime(n+1)，这是第n+1个task并不会因为到时了而执行，他会等待第n个task执行完之后再执行，那么这样势必会导致n+2个的执行实现scheduledExecutionTime放生改变即scheduledExecutionTime(n+2) = realExecutionTime(n+1)+periodTime。所以这两个方法更加注重保存间隔时间的稳定。

      3、scheduleAtFixedRate(TimerTask task, Date firstTime, long period)、scheduleAtFixedRate(TimerTask task, long delay, long period)

      在前面也提过scheduleAtFixedRate与schedule方法的侧重点不同，schedule方法侧重保存间隔时间的稳定，而scheduleAtFixedRate方法更加侧重于保持执行频率的稳定。为什么这么说，原因如下。在schedule方法中会因为前一个任务的延迟而导致其后面的定时任务延时，而scheduleAtFixedRate方法则不会，如果第n个task执行时间过长导致systemCurrentTime>= scheduledExecutionTime(n+1)，则不会做任何等待他会立即执行第n+1个task，所以scheduleAtFixedRate方法执行时间的计算方法不同于schedule，而是scheduledExecutionTime(n)=firstExecuteTime +n*periodTime，该计算方法永远保持不变。所以scheduleAtFixedRate更加侧重于保持执行频率的稳定。

Timer的缺陷

Timer计时器可以定时（指定时间执行任务） 延迟   周期性执行，但是TImer存在一定的缺陷。

1.首先Timer对调度的支持是基于绝对时间的，而不是相对时间，所以他对系统时间的改变非常敏感。

2.其次Timer线程是不会捕获异常的，如果TimerTask抛出了异常则会导致Timer线程终止，同时Timer也不会重新恢复线程的执行，他会错误的认为整个Timer线程都会取消。同时，已经被安排但尚未执行的TimerTask也不会再执行了，新的任务也不能被调度。故如果TimerTask抛出未检测的异常，Timer将产生无法预料的行为。

缺陷一：Timer管理实践延迟缺陷

public class TimerTest04 {  
    private Timer timer;  
    public long start;     
      
    public TimerTest04(){  
        this.timer = new Timer();  
        start = System.currentTimeMillis();  
    }  
      
    public void timerOne(){  
        timer.schedule(new TimerTask() {  
            public void run() {  
            	System.out.println(Thread.currentThread().getName());
                System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));  
                try {  
                    Thread.sleep(4000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }, 1000);  
    }  
      
    public void timerTwo(){  
        timer.schedule(new TimerTask() {  
            public void run() {  
            	System.out.println(Thread.currentThread().getName());
                System.out.println("timerTwo invoked ,the time:" + (System.currentTimeMillis() - start));  
            }  
        }, 3000);  
    }  
      
    public static void main(String[] args) throws Exception {  
        TimerTest04 test = new TimerTest04();  
          
        test.timerOne();  
        test.timerTwo();  
    }  
}

打印结果：

设置了timeTow是在3秒后执行，但是却在启动后5秒执行了。 原因：Timer内部是单线程，timer2必须等待timer1执行完毕后再执行，由于timer1执行消耗了5秒，相对timer2的3秒大，所以timer2无需再等待，在timer1执行完毕后即立即执行。

缺陷二：Timer抛出异常缺陷

public class TimerTest05 {  
    private Timer timer;  
      
    public TimerTest05(){  
        this.timer = new Timer();  
    }  
      
    public void timerOne(){  
        timer.schedule(new TimerTask() {  
            public void run() {  
                throw new RuntimeException();  
            }  
        }, 1000);  
    }  
      
    public void timerTwo(){  
        timer.schedule(new TimerTask() {  
              
            public void run() {  
                System.out.println("我会不会执行呢？？");  
            }  
        }, 1000);  
    }  
      
    public static void main(String[] args) {  
        TimerTest05 test = new TimerTest05();  
        test.timerOne();  
        test.timerTwo();  
    }  
}

执行结果：

timerOne抛出异常，导致timerTwo任务终止。

对于Timer的缺陷，我们可以使用ScheduledThreadPoolExecutor来代替。Timer是基于绝对时间的，对系统时间比较敏感，而ScheduledThreadPoolExecutor是基于相对时间；Timer是内部单一线程，而ScheduledThreadPoolExecutor内部是个线程池，可以支持多个任务并发执行。

用ShceduledExecutorService替代TImer：

解决问题1：

public class ScheduledExecutorTest {  
    private  ScheduledExecutorService scheduExec;  
      
    public long start;  
      
    ScheduledExecutorTest(){  
        this.scheduExec =  Executors.newScheduledThreadPool(2);    
        this.start = System.currentTimeMillis();  
    }  
      
    public void timerOne(){  
        scheduExec.schedule(new Runnable() {  
            public void run() {  
                System.out.println("timerOne,the time:" + (System.currentTimeMillis() - start));  
                try {  
                    Thread.sleep(4000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        },1000,TimeUnit.MILLISECONDS);  
    }  
      
    public void timerTwo(){  
        scheduExec.schedule(new Runnable() {  
            public void run() {  
                System.out.println("timerTwo,the time:" + (System.currentTimeMillis() - start));  
            }  
        },2000,TimeUnit.MILLISECONDS);  
    }  
      
    public static void main(String[] args) {  
        ScheduledExecutorTest test = new ScheduledExecutorTest();  
        test.timerOne();  
        test.timerTwo();  
    }  
}

执行结果：

解决问题2：

public class ScheduledExecutorTest02  {  
	public static void main(String[] args) throws InterruptedException {
		final TimerTask task1 = new TimerTask() {
			@Override
			public void run() {
				throw new RuntimeException();
			}
		};
		final TimerTask task2 = new TimerTask() {
			@Override
			public void run() {
				System.out.println("task2 invoked!");
			}
		};
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
		pool.schedule(task1, 100, TimeUnit.MILLISECONDS);
		pool.scheduleAtFixedRate(task2, 0, 1000, TimeUnit.MILLISECONDS);
	}  
}

ScheduledExecutorService可以保证，task1出现异常时，不影响task2运行。因为使用了两个核心线程

漫步夕阳下
关注
专栏目录
Java: 线程池(ExecutorService、Executors)+定时器（ ScheduledExecutorService、Timer）
qq_54508596的博客
08-02 567
Java: 线程池(ExecutorService、Executors)+定时器（ ScheduledExecutorService、Timer）
Timer延时执行与ScheduledExecutorService的区别
leibaoxue的博客
10-12 228
在执行延时执行的时候，Timer抛出异常之后会出现线程终止，无法进行下个线程的执行（利用idea中的插件检测出来的） 上代码 import java.util.Timer; import java.util.TimerTask; public class TimerTest { private Timer timer = new Timer(); public void launchTimer() { timer.schedule(new TimerTask()
Timer和ScheduledExecutorService
thebigdipperbdx的博客
01-18 382
介绍 Timer和ScheduledExecutorService，可以定时周期性的执行任务 Timer、TimerTask，是被synchronized修饰的线程安全的类 使用ScheduledExecutorService代替Timer吧 多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecut...
ScheduledExecutorService 和 timer的区别
linpaipai的博客
04-17 815
ScheduledExecutorService 和 timer的区别： 1.前者有线程池 可以支持多个任务并发执行 后者是单线程（当执行任务的时间间隔小于执行任务的时间， timer就会等待上一个任务执行结束才执行下一个） 2.程序运行报错（RuntimeException）时，timer会停止所有任务的运行 3.timer时间间隔是依赖于系统的时间，而前者是基于时间的延迟 ...
Timer 和 ScheduleExecutorService 区别 (转)
weixin_33722405的博客
12-20 328
原文: http://sunnylocus.iteye.com/blog/530969 ----------------------------------------------- java.util.Timer计时器有管理任务延迟执行("如1000ms后 执行任务")以及周期性执行("如每500ms执行一次该任务")。但是，Timer存在一些缺陷，因此你应该考虑使用 Scheduled...
Timer与ScheduledExecutorService间的抉择
ywb201314的专栏
02-29 391
java.util.Timer计时器有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。 但是，Timer存在一些缺陷，因此你应该考虑使用ScheduledThreadPoolExecutor作为代替品,Timer对调度的支持是基于绝对时间,而不是相对时间的， 由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支
Timer与ScheduledExecutorService定时器的比较及其简单事例
学习笔记
10-17 3310
import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.ut
Java定时器实现：Timer与ScheduledExecutorService比较
`scheduleAtFixedRate()`方法用于固定周期地执行任务，与`Timer`的`schedule()`不同，它会确保每个周期内任务精确执行，并在下一次执行之间提供固定的等待时间。在示例中，任务将在1秒后首次执行，然后每5秒重复一次...
Java定时器Timer简述共8页.pdf.zip
11-22
虽然Java定时器可以用来调度任务，但它不同于Java的ExecutorService或ScheduledExecutorService。后者是Java并发API的一部分，提供了更高级的线程管理和任务调度功能，如更灵活的定时策略，支持取消和中断任务等。 ...
ScheduledThreadPoolExecutor 与 Timer
最新发布
09-15
ScheduledThreadPoolExecutor与Timer是用于实现定时任务调度的类。二者有一些相似之处，但也有很多不同之处。 ScheduledThreadPoolExecutor是Java5引入的类，它实现了ExecutorService接口，提供了更强大和灵活的...
定时器ScheduledExecutorService与Timer
hqyhqyhq的专栏
10-09 742
1、Timer系统时间向前修改，定时器将被挂起，不再执行，除非时间回到了之前系统时间。 2、ScheduledExecutorService不受系统时间变更影响。 3、ScheduledExecutorService用法（多个定时任务，用法与Timer雷同）： // 对象申明 private ScheduledExecutorService mScheduledExecutorService = Executors.newScheduledThreadPool (2); pr.
java ScheduledExecutorService、Timer 多线程与定时任务的结合使用
あずにゃん梓喵的博客
04-29 1641
第一种方式：多线程 + 定时任务 执行，会专门使用一个线程执行 定时任务 package com.nginxlog; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.concurrent.*; public class ScheduledExecutorSe...
ScheduledExecutorService 和 Timer 的区别
wangxueqing52的博客
04-26 4377
Timer的内部只有一个线程，如果有多个任务的话就会顺序执行，这样我们的延迟时间和循环时间就会出现问题。ScheduledExecutorService是线程池，所以就不会出现这个情况，在对延迟任务和循环任务要求严格的时候，就需要考虑使用ScheduledExecutorService了。ScheduledExecutorService有三种常用方法: // 通过静态方法创建ScheduledEx...
定时任务实现Timer, TimeTask, ScheduledExecutorService及Spring定时器
热门推荐
马靖的个人技术博客
11-21 1万+
在工作中，我们往往会遇到这样的需求，那就是我们可能需要定期的去处理一个任务，如定期的清理一些文件、定期离线爬取一些数据等，更多的时候是在凌晨别人都进入梦乡的时候偷偷的完成某些任务，这时候我们就需要知道如何去实现一个定时任务了。 定时任务，简单的来说就是我们可以控制一个任务单元的执行时间和执行频率。那么有什么方法可以实现呢？下面我们从简单的开始说起。 （1）Timer JDK中
TimerTask,Timer,ExecutorService
weixin_30545285的博客
05-28 69
TimerTask用法类似于Thread，重写其run()方法，中断用timerTask.cancel()。Timer是一个线程，可以往里添加TimerTask，timer.scheduleAtFixedRate（timerTask,延迟执行时间，循环周期时间），中断用timer.cancel()，以timer的线程来执行该执行的timerTask的任务。若timer中的timerTask较多，t...
Java定时任务Timer、TimerTask与ScheduledThreadPoolExecutor详解
weixin_33866037的博客
01-19 433
　 定时任务就是在指定时间执行程序，或周期性执行计划任务。Java中实现定时任务的方法有很多，本文从从JDK自带的一些方法来实现定时任务的需求。 一、Timer和TimerTask 　 Timer和TimerTask可以作为线程实现的第三种方式（前两种详见《Java多线程基础》），JDK1.5之后定时任务推荐使用ScheduledThreadPoolExecutor。 1、快速入门 　...
浅谈java定时任务：TimerTask
殷素素的博客
03-31 4603
java 定时任务TimerTask定时任务有很多种实现，网上也有很多开源的定时任务框架可以参考，但博主只简单介绍一下博主使用到的四种定时任务的实现：Timer和TimerTaks、spring、quartz、spring和quartz。话不多说，直接上代码 Timer和TimerTask我们先来看看Timer的源码 public void schedule(TimerTask task, Da
TaskExecutor整理
weixin_30341745的博客
02-28 97
Spring的TaskExecutor接口等同于java.util.concurrent.Executor接口。 实际上，它存在的主要原因是为了在使用线程池的时候，将对Java 5的依赖抽象出来。 这个接口只有一个方法execute(Runnable task)，它根据线程池的语义和配置，来接受一个执行任务。 /** * 异步调用 */ private T...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值