精华内容
下载资源
问答
  • JAVA定时器
    2021-03-14 23:25:53

    简单的定时器

    定时器类Timer在java.util包中。使用时,先实例化,然后使用实例的schedule(TimerTask task, long delay)方法,设定指定的任务task在指定的延迟delay后执行。定时器任务类TimerTask是抽象类,继承并重写其run()方法,可实现具体任务。

    schedule(TimerT ask task, Date time)

    设定指定任务task在指定时间time执行。

    cancel()

    方法结束这个定时器。

    schedule(TimerT ask task, long delay, long period)

    方法设定指定任务task在指定延迟delay后进行固定延迟peroid的执行。scheduleAtFixedRate(TimerTask task, long delay, long period)

    方法设定指定任务task在指定延迟delay后进行固定频率peroid的执行。

    要实现一个定时任务,运用java中的Timer和TimerTask类可以非常容易实现实时调用处理函数。这两个类使用起来非常方便,可以完成我们对定时器的绝大多数需要。

    看个简单的例子:

    import java.io.IOException;

    import java.util.Timer;

    public class TimerTest {

    public static void main(String[] args){

    Timer timer = new Timer();

    //在1秒后执行此任务,每次间隔2秒,如果传递一个Data参数,就可以在某个固定的时间执行这个任务.

    更多相关内容
  • java定时器

    2017-01-19 15:46:55
    java定时器,import java.util.Calendar; import java.util.Date; import java.util.Timer; import java.util.TimerTask; 规定每天几点执行一次
  • Java定时器

    2015-06-15 22:49:40
    Java定时器,实现以圈计时和以秒计时两种功能。特比适合Java初学者
  • 超级简单易用的java定时器,1个源程序,一个配置文件,再加一个配置项,完美搞定
  • 主要介绍了java 定时器线程池(ScheduledThreadPoolExecutor),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java定时器 quartz jar包

    2017-11-02 17:41:17
    Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建...Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.0。
  • Java 定时器

    2022-02-04 17:50:54
    1、Timer定时器(一般不会用) 可使用 public Timer()构造器创建Timer对象 使用方法schedule(TimerTask task,long delay,long period)来开启一个定时器,按照计划处理TimerTask任务。 import java.util.Timer; ...

    1、Timer定时器(一般不会用)

    可使用 public Timer()构造器创建Timer对象

    使用方法schedule(TimerTask task,long delay,long period)来开启一个定时器,按照计划处理TimerTask任务。

    import java.util.Timer;
    import java.util.TimerTask;
    
    public class TimerDemo1 {
        public static void main(String[] args) {
            //1、创建定时器对象
            Timer timer=new Timer();
            //2、调用方法,处理定时任务
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行了一次");
                }
            },2000,3000);
            //等两秒开始运行,隔三秒运行一次
        }
    }

    Timer定时器的特点和存在的问题

    1、Timer时单线程,处理多个任务时排队进行,存在延时与设置定时器的时间有出入

    2、可能会因为某个任务异常使Timer线程死掉,影响后续任务执行

    因此引入了ScheduledExercutorService定时器

    2、*ScheduledExercutorService定时器(内部为线程池)

    Exercutor的方法:newScheduledThreadPool(int corePoolSize) 得到线程池对象

    ScheduledExercutorService的方法:

    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period,TimeUnit unit)

    参数一:TimerTask任务(实现了Runnable接口)

    参数二:多长时间后开始执行

    参数三:隔多长时间执行一次

    参数四:时间单位

    import java.util.TimerTask;
    import java.util.concurrent.*;
    
    
    public class TimerDemo2 {
        public static void main(String[] args) {
            ScheduledExecutorService pool= Executors.newScheduledThreadPool(3);
            pool.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行输出AAA");
    //                try {
    //                    Thread.sleep(50000);
    //                } catch (Exception e) {
    //                    e.printStackTrace();
    //                }
                    System.out.println(10/0);
                }//睡眠和异常都不会影响其他线程的任务
            },2,2, TimeUnit.SECONDS);
            //这里线程池定时器,一个线程池遇到异常或处理时间较长的任务时,不会影响其他线程的执行
            pool.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                        System.out.println(Thread.currentThread().getName()+"执行输出BBB");
                }
            },2,5, TimeUnit.SECONDS);
        }
    }

    优点:基于线程池,某个任务的执行不会影响其他任务

    一般使用ScheduledExercutorService。

    展开全文
  • java定时器+多线程(池)+java队列Demo
  • NULL 博文链接:https://ynshun.iteye.com/blog/1917218
  • JAVA定时器时间抓取

    2018-09-08 09:32:06
    这些demo案例是笔者,之前在开发过程中用到的一些测试案例,很实用,几乎和时间相关的都有了。
  • java 定时器

    2017-03-27 16:37:37
    很强大的计时器,跑批必备利器,很实用
  • Java定时器(Timer)

    千次阅读 2021-06-19 16:48:42
    Timer和TimerTask是用于在后台线程中调度任务的java util类。简单地说,TimerTask是要执行的任务,Timer是调度器。 2.调度一次性任务 2.1 指定延迟后执行 让我们从简单地在定时器的帮助下运行单个任务开始: @Test ...

    1.介绍

    Timer和TimerTask是用于在后台线程中调度任务的java util类。简单地说,TimerTask是要执行的任务,Timer是调度器。

    2.调度一次性任务

    2.1 指定延迟后执行

    让我们从简单地在定时器的帮助下运行单个任务开始:

    @Test
    public void givenUsingTimer_whenSchedulingTaskOnce_thenCorrect() {
        TimerTask task = new TimerTask() {
            public void run() {
                System.out.println("Task performed on: " + new Date() + "n" +
                  "Thread's name: " + Thread.currentThread().getName());
            }
        };
        Timer timer = new Timer("Timer");
        
        long delay = 1000L;
        timer.schedule(task, delay);
    }
    

    延迟时间作为schedule()方法的第二个参数给出。我们将在下一节中了解如何在给定的日期和时间执行任务。

    注意,如果我们正在运行这是一个JUnit测试,我们应该添加一个Thread.sleep(delay*2)调用,以允许定时器的线程在JUnit测试停止执行之前运行任务。

    2.2 指定时间执行

    现在,让我们看看Timer#schedule(TimerTask,Date)方法,它将日期而不是long作为其第二个参数,这实现了在某个时刻而不是在延迟之后执行任务。

    这一次,让我们假设我们有一个旧的遗留数据库,我们希望将它的数据迁移到一个具有更好模式的新数据库中。我们可以创建一个DatabaseMigrationTask类来处理该迁移:

    public class DatabaseMigrationTask extends TimerTask {
        private List<String> oldDatabase;
        private List<String> newDatabase;
    
        public DatabaseMigrationTask(List<String> oldDatabase, List<String> newDatabase) {
            this.oldDatabase = oldDatabase;
            this.newDatabase = newDatabase;
        }
    
        @Override
        public void run() {
            newDatabase.addAll(oldDatabase);
        }
    }
    

    为简单起见,我们用字符串列表来表示这两个数据库。简单地说,我们的迁移就是将第一个列表中的数据放到第二个列表中。要在所需的时刻执行此迁移,我们必须使用schedule()方法的重载版本:

    List<String> oldDatabase = Arrays.asList("Harrison Ford", "Carrie Fisher", "Mark Hamill");
    List<String> newDatabase = new ArrayList<>();
    
    LocalDateTime twoSecondsLater = LocalDateTime.now().plusSeconds(2);
    Date twoSecondsLaterAsDate = Date.from(twoSecondsLater.atZone(ZoneId.systemDefault()).toInstant());
    
    new Timer().schedule(new DatabaseMigrationTask(oldDatabase, newDatabase), twoSecondsLaterAsDate);
    

    我们将迁移任务和执行日期赋予schedule()方法。然后,在twoSecondsLater指示的时间执行迁移:

    while (LocalDateTime.now().isBefore(twoSecondsLater)) {
        assertThat(newDatabase).isEmpty();
        Thread.sleep(500);
    }
    assertThat(newDatabase).containsExactlyElementsOf(oldDatabase);
    

    虽然我们在这一刻之前,迁移并没有发生。

    3.调度一个可重复执行任务

    既然我们已经讨论了如何安排任务的单个执行,那么让我们看看如何处理可重复的任务。同样,Timer类提供了多种可能性:我们可以将重复设置为观察固定延迟或固定频率。

    • 固定延迟:意味着执行将在最后一次执行开始后的一段时间内开始,即使它被延迟(因此它本身被延迟)。假设我们想每两秒钟安排一个任务,第一次执行需要一秒钟,第二次执行需要两秒钟,但是延迟了一秒钟。然后,第三次执行将从第五秒开始:

    • 固定频率:意味着每次执行都将遵守初始计划,无论之前的执行是否被延迟。让我们重用前面的示例,使用固定的频率,第二个任务将在3秒钟后开始(因为延迟)。但是,四秒钟后的第三次执行(关于每两秒钟执行一次的初始计划):

    关于这两种调度方式,让我们看看如何使用它们:

    为了使用固定延迟调度,schedule()方法还有两个重载,每个重载都使用一个额外的参数来表示以毫秒为单位的周期性。为什么两次重载?因为仍然有可能在某个时刻或某个延迟之后开始执行任务。

    至于固定频率调度,我们有两个scheduleAtFixedRate()方法,它们的周期也是以毫秒为单位的。同样,我们有一种方法可以在给定的日期和时间启动任务,还有一种方法可以在给定的延迟后启动任务。

    注意一点:如果一个任务的执行时间超过了执行周期,那么无论我们使用固定延迟还是固定速率,它都会延迟整个执行链。

    3.1 固定延迟

    现在,让我们设想一下,我们要实现一个通讯系统,每周向我们的追随者发送一封电子邮件。在这种情况下,重复性任务似乎是理想的。所以,让我们安排每秒钟的通讯,这基本上是垃圾邮件,但由于发送是假的,所以不用在意:)

    让我们首先设计一个任务:

    public class NewsletterTask extends TimerTask {
        @Override
        public void run() {
            System.out.println("Email sent at: " 
              + LocalDateTime.ofInstant(Instant.ofEpochMilli(scheduledExecutionTime()), 
              ZoneId.systemDefault()));
        }
    }
    

    每次执行时,任务都会打印其调度时间,我们使用TimerTask#scheduledExecutionTime()方法收集这些时间。那么,如果我们想在固定延迟模式下每秒钟安排一次这个任务呢?我们必须使用前面提到的schedule()的重载版本:

    new Timer().schedule(new NewsletterTask(), 0, 1000);
    
    for (int i = 0; i < 3; i++) {
        Thread.sleep(1000);
    }
    

    当然,我们只对少数情况进行测试:

    Email sent at: 2020-01-01T10:50:30.860
    Email sent at: 2020-01-01T10:50:31.860
    Email sent at: 2020-01-01T10:50:32.861
    Email sent at: 2020-01-01T10:50:33.861

    如上所示,每次执行之间至少有一秒钟的间隔,但有时会延迟一毫秒。这种现象是由于我们决定使用固定延迟重复。

    3.3 调度一个每日任务

    @Test
    public void givenUsingTimer_whenSchedulingDailyTask_thenCorrect() {
        TimerTask repeatedTask = new TimerTask() {
            public void run() {
                System.out.println("Task performed on " + new Date());
            }
        };
        Timer timer = new Timer("Timer");
        
        long delay = 1000L;
        long period = 1000L * 60L * 60L * 24L;
        timer.scheduleAtFixedRate(repeatedTask, delay, period);
    }
    

    4.取消调度器和任务

    4.1 在Run方法中去掉调度任务

    在run()方法对TimerTask本身的实现中调用TimerTask.cancel()方法:

    @Test
    public void givenUsingTimer_whenCancelingTimerTask_thenCorrect()
      throws InterruptedException {
        TimerTask task = new TimerTask() {
            public void run() {
                System.out.println("Task performed on " + new Date());
                cancel();
            }
        };
        Timer timer = new Timer("Timer");
        
        timer.scheduleAtFixedRate(task, 1000L, 1000L);
        
        Thread.sleep(1000L * 2);
    }
    

    4.2 取消定时器

    调用Timer.cancel()方法:

    @Test
    public void givenUsingTimer_whenCancelingTimer_thenCorrect() 
      throws InterruptedException {
        TimerTask task = new TimerTask() {
            public void run() {
                System.out.println("Task performed on " + new Date());
            }
        };
        Timer timer = new Timer("Timer");
        
        timer.scheduleAtFixedRate(task, 1000L, 1000L);
        
        Thread.sleep(1000L * 2); 
        timer.cancel(); 
    }
    

    5.Timer对比ExecutorService

    我们也可以使用ExecutorService来安排定时器任务,而不是使用定时器。下面是一个在指定间隔运行重复任务的快速示例:

    @Test
    public void givenUsingExecutorService_whenSchedulingRepeatedTask_thenCorrect() 
      throws InterruptedException {
        TimerTask repeatedTask = new TimerTask() {
            public void run() {
                System.out.println("Task performed on " + new Date());
            }
        };
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        long delay  = 1000L;
        long period = 1000L;
        executor.scheduleAtFixedRate(repeatedTask, delay, period, TimeUnit.MILLISECONDS);
        Thread.sleep(delay + period * 3);
        executor.shutdown();
    }
    

    那么定时器和ExecutorService解决方案之间的主要区别是什么:

    • 定时器对系统时钟的变化敏感;ScheduledThreadPoolExecutor并不会。
    • 定时器只有一个执行线程;ScheduledThreadPoolExecutor可以配置任意数量的线程。
    • TimerTask中抛出的运行时异常会杀死线程,因此后续的计划任务不会继续运行;使用ScheduledThreadExecutor–当前任务将被取消,但其余任务将继续运行。

    6.本文代码

    Java定时器样例代码

    展开全文
  • JAVA定时器JAVA定时器.pdf
  • java定时器实现总结

    2021-03-06 03:57:12
    前言:Java定时器目前主要有3种实现方式:JDK组件,Spring Task,Quartz框架。1. JDK组件(1) java.util.TimerTaskMyTimerTask.java:public class MyTimerTask extendsTimerTask {@Overridepublic voidrun() {System...

    前言:Java定时器目前主要有3种实现方式:JDK组件,Spring Task,Quartz框架。

    0987baa926bd33171d1bdc7e65969797.png

    1. JDK组件

    (1) java.util.TimerTask

    6e9a808a9854df071194cc8bb253e01c.png

    MyTimerTask.java:

    public class MyTimerTask extendsTimerTask {

    @Overridepublic voidrun() {

    System.out.println("MyTimerTask, now: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(newDate()));

    }public static voidmain(String[] args) {

    Timer timer= newTimer();

    timer.schedule(new MyTimerTask(), 1000, 1000);//timer.cancel();//停止调度器}

    }

    (2) java.util.concurrent.ScheduledThreadPoolExecutor(JDK5.0+之后推荐使用)

    1fcbefde0d2adc1d74c20d9f9548f029.png

    MyScheduledTask.java:

    public class MyScheduledTask implementsRunnable {public voidrun() {

    System.out.println("my scheduled task, now: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(newDate()));

    }

    }

    MyScheduledExecutor.java:

    public classMyScheduledExecutor {public static voidmain(String[] args) {

    ScheduledThreadPoolExecutor executor= new ScheduledThreadPoolExecutor(10);

    ScheduledFuture future= executor.scheduleWithFixedDelay(new MyScheduledTask(), 1000, 1000, TimeUnit.MILLISECONDS);//future.cancel(true);//停止定时任务,Timer不能停止定时任务,只能关闭调度器//executor.shutdown();//关闭调度器

    }

    }

    比较:java.util.concurrent.ScheduledThreadPoolExecutor比java.util.Timer更加灵活和高效。

    2. Spring Task

    (1) xml配置方式实现

    TaskJob.java:

    @Servicepublic classTaskJob {public voidjob1() {

    System.out.println("指定Spring定时任务1, now: " + new SimpleDateFormat("yyy-MM-dd HH:mm:ss").format(newDate()));

    }

    }

    spring.xml:

    xsi:schemaLocation="

    ...

    http://www.springframework.org/schema/task

    http://www.springframework.org/schema/task/spring-task-3.0.xsd">

    (2) 注解方式实现

    TaskJob2.java:

    @Componentpublic classTaskJob2 {/*** 每隔一秒执行一次*/@Scheduled(cron="0/1 * * * * ?")public voidjob2() {

    System.out.println("注解方式使用spring定时任务框架, now: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(newDate()));

    }

    }

    spring.xml:

    xsi:schemaLocation="

    ...

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.0.xsd

    http://www.springframework.org/schema/task

    http://www.springframework.org/schema/task/spring-task-3.0.xsd">

    (1) 独立使用Quartz(详见Quartz官方示例):

    pom.xml:

    org.quartz-scheduler

    quartz

    2.2.1

    org.quartz-scheduler

    quartz-jobs

    2.2.1

    定义定时任务,MyJob.java:

    public class MyJob implementsJob {public void execute(JobExecutionContext arg0) throwsJobExecutionException {

    System.out.println("执行Quartz定时任务实现, now: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(newDate()));

    }

    }

    调度定时任务,MyJobSheduler:

    public classMyJobSheduler {public static voidmain(String[] args) {try{

    JobDetail job= JobBuilder.newJob(MyJob.class).withIdentity("myJob").build();

    Trigger trigger=TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")

    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())

    .build();

    Scheduler scheduler=StdSchedulerFactory.getDefaultScheduler();

    scheduler.scheduleJob(job, trigger);

    scheduler.start();

    }catch(SchedulerException e) {

    e.printStackTrace();

    }

    }

    }

    【实现比较】

    实现方式

    优点

    缺点

    JDK组件

    无需引入第三方依赖,控制灵活

    仅支持简单任务调度,不支持指定日期等复杂定时任务

    SpringTask

    功能相对JDK方式全面(简单或指定日期等复杂任务调度),支持注解和配置2种方式

    Quartz

    开源,功能全面且强大(简单或指定日期等复杂任务调度),可独立使用,也可以与Spring集成 必须在项目中引入quartz依赖

    在项目中必须引入quartz依赖

    【使用总结】

    1. J2EE项目

    -- 未依赖Spring框架,建议使用Quartz。

    -- 引入了Spring 3.x+,如果仅需要简单定时任务控制,建议使用Spring Task;否则建议使用Quartz。

    -- 特别地,在Spring Boot项目中,根据需求可以灵活选择JDK,Spring Task或者Quartz。

    2. 非J2EE项目

    -- 简单定时任务控制,建议使用JDK实现:java.util.concurrent.ScheduledThreadPoolExecutor;否则建议使用Quartz。

    附:在Linux环境下,可以直接使用crontab程序实现简单的定时任务,比如定时全量备份MySQL数据库。

    7280df79620297e091f6f720f513c7d6.png

    展开全文
  • Java定时器——springboot定时器篇 文章目录Java定时器——springboot定时器篇前言一、Java定时器是什么?二、路径1.体验2.编写启动类,添加定时器注解3.编写处理类cron表达式总结结语 前言 大家好我是程序员阿毛...
  • Java定时器Timer简述

    2020-08-31 16:39:28
    本文主要介绍了Java定时器Timer的相关知识,具有一定的参考价值,下面跟着小编一起来看下吧
  • 可重置Java定时器

    2021-02-25 19:38:58
    我想有一个java.utils.Timer与一个可重置时间在java.I需要设置一次off事件发生在X秒。如果在创建定时器的时间和X秒之间没有发生任何事情,则事件会正常发生。然而,如果在X秒之前,我决定该事件应该发生在Y秒后,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,169
精华内容 29,667
关键字:

java定时器

java 订阅
友情链接: xpxnpok436.rar