Timer缺点 java java中timer类

Java Timer类在特定的时间间隔内执行一次或重复的任务或作业。它是 Java 实用程序类的一部分。此类还用于使用其内置方法在指定日期安排作业。

如果我们想创建自己的任务，我们必须扩展TimerTask类，它是一个抽象类。计时器类使用此任务进行调度。也就是说，Timer 用作调度器，TimerTask 是需要调度的作业。

Java 定时器构造函数

我们可以使用以下构造函数创建 Timer 对象

构造函数	描述
Timer()	这是默认计时器
Timer(boolean isDaemon)	这将创建一个计时器及其关联线程作为守护程序运行
Timer(String name)	这将创建一个带有指定名称的关联线程的计时器
Timer(String name, boolean isDaemon)	这将创建一个带有指定名称的关联线程的计时器，并且可以作为守护进程运行

Timer t = new Timer();

Java 定时器方法

方法	描述	参数
void cancel()	终止计时器。它取消除当前正在运行的任务之外的所有计划任务（如果有）
int purge()	这将从队列中删除所有已取消的任务并返回已删除的任务数。
void schedule(TimerTask task, Date time)	安排指定任务在指定时间运行。如果时间过去，则立即执行	task - 要执行 的任务 time -必须执行任务的时间
void schedule(TimerTask task,long delay)	在指定延迟后安排指定任务	task - 要执行的任务 delay - 任务执行前的延迟毫秒数
void schedule(TimerTask task, Date firsttime, long period)	在特定开始时安排特定任务，以便以提到的周期性间隔重复执行	task - 要执行 的任务 firsttime - 执行 期间任务的开始时间 - 必须执行任务的间隔
void schedule(TimerTask task, long delay, long period)	在指定的延迟后以提到的周期性间隔安排特定任务以重复执行	task - 要执行的任务 delay - 任务执行前的延迟时间 period - 必须执行任务的时间间隔
vois scheduleAtFixedRate(TimerTask task, Date firsttime, long period)	从特定日期开始，以所述定期间隔安排以固定速率执行的特定任务	task - 要执行 的任务 firsttime - 执行 期间任务的开始时间 - 必须执行任务的间隔
void scheduleAtFixedRate(TimerTask task,long delay,long period)	在指定的延迟后以上述周期性间隔安排特定任务以重复固定速率执行	task - 要执行的任务 delay - 任务执行前的延迟时间 period - 必须执行任务的时间间隔

定时器异常

Java Timer 类在调度任务时抛出以下异常：

• NullPointerException – 当任务或时间为空时
• IllegalArgumentException – 当时间或延迟或周期为负数时
• IllegalStateException – 如果任务已被安排或取消，定时器被取消或定时器线程被终止

Java Timer：使用 schedule(task, time) 安排任务

让我们看一个在指定时间使用 java 计时器调度任务的简单示例。首先，我们创建一个新的计时器对象't'。然后，我们创建一个TimerTask对象“任务”并通过覆盖run方法提供所需的代码。然后我们在指定时间（这里是当前时间）使用计时器安排任务。

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerDemo {
  public static void main(String[] args) {
    Timer t = new Timer();
    TimerTask task = new TimerTask(){
      public void run()
      {
        for(int i=1;i<=5;i++) {
          System.out.println("Task : " + i);
        }
      }
      
    };
    
    t.schedule(task, new Date());
  }
}

输出

Task : 1
Task : 2
Task : 3
Task : 4
Task : 5

Java Timer：使用 schedule(task, delay) 安排任务

在下面的示例中，我们将任务安排在延迟 5 秒后执行。如果您看到输出，您可以清楚地看到 Java Timer 在延迟 5 秒后执行了任务。

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
public class TimeDemoDelay {
  public static void main(String[] args) {
    Timer t = new Timer();
    TimerTask task = new TimerTask() {
      public void run()
      {
        System.out.println("Timer executed at time: "+ new Date());
      }
    };
    System.out.println("Current time: " + new Date());
    t.schedule(task, 5000);
  }
}

输出

Current time: Sat Jun 27 16:01:03 IST 2020
Timer executed at time: Sat Jun 27 16:01:08 IST 2020

Java Timer：使用 schedule(task, time, period) 安排任务

在下面的示例中，我们可以看到我们可以安排任务以从指定时间开始以固定时间间隔重复执行。

这里，Java Timer 从当前时间开始执行任务，并在每 2 秒后继续执行。由于我们要在特定时间后取消任务，所以我们根据一定的条件调用取消方法，否则它将继续执行。在我们的示例中，我们将条件设置为 i=5。一旦达到此限制，Java Timer 将取消任务并停止执行。

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
public class TimerDemo1 {
  public static void main(String[] args) {
    Timer t = new Timer();
    TimerTask task = new TimerTask() {
      int i=1;
      public void run() {
        System.out.println("Timer executed at :" + new Date());
        if(i==5)
          t.cancel();
        i=i+1;
      }
    };
    
    System.out.println("Current time: " + new Date());
    t.schedule(task, new Date(), 2000);
  }
}

输出

Current time: Sat Jun 27 16:13:33 IST 2020
Timer executed at :Sat Jun 27 16:13:33 IST 2020
Timer executed at :Sat Jun 27 16:13:35 IST 2020
Timer executed at :Sat Jun 27 16:13:37 IST 2020
Timer executed at :Sat Jun 27 16:13:39 IST 2020
Timer executed at :Sat Jun 27 16:13:41 IST 2020

Java Timer：使用 schedule(task, delay, period) 安排任务

在下面的示例中，我们安排一个任务在特定延迟（即 5 秒）后重复执行，Java Timer 在特定时间间隔内执行此任务。即使时间间隔为 1 秒，由于另一个线程休眠 2 秒，该线程每 2 秒执行一次。因此，如果您看到只有第一个任务执行，总延迟为 3 秒，其余任务每 2 秒执行一次。

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerDelayPeriod {
  public static void main(String[] args) {
    Timer t = new Timer();
    TimerTask task = new TimerTask() {
      int i=1;
      public void run() {
        System.out.println("Timer executed at :" + new Date());
        try {
          Thread.sleep(2000);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        if(i==5)
          t.cancel();
        i=i+1;
      }
    };
    
    System.out.println("Current time: " + new Date());
    t.schedule(task, 5000, 1000);
  }
}

输出

Current time: Sun Jun 28 20:04:37 IST 2020
Timer executed at :Sun Jun 28 20:04:42 IST 2020
Timer executed at :Sun Jun 28 20:04:44 IST 2020
Timer executed at :Sun Jun 28 20:04:46 IST 2020
Timer executed at :Sun Jun 28 20:04:48 IST 2020
Timer executed at :Sun Jun 28 20:04:50 IST 2020

使用 scheduleAtFixedRate(task,time,period) 安排任务

当我们希望从特定时间开始以固定速率重复执行时，此方法很有用。在下面的示例中，我们可以看到任务执行间隔为 1 秒，但由于另一个线程休眠了 3 秒，Java Timer 每隔 3 秒执行一次任务。由于这 1 秒包含在 3 秒限制内，因此它不会再等待额外的 1 秒，而是立即开始执行下一个任务。

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
public class TimerFixedRateDemo {
  public static void main(String[] args) {
    Timer t = new Timer();
    TimerTask task = new TimerTask() {
      int i=1;
      public void run()
      {
        System.out.println("Task executed at time: " + new Date());
        try {
          Thread.sleep(3000);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        if(i==5)
          t.cancel();
        i=i+1;
      }
    };
    t.scheduleAtFixedRate(task, new Date(), 1000);
  }
}

输出

Task executed at time: Sun Jun 28 22:54:00 IST 2020
Task executed at time: Sun Jun 28 22:54:03 IST 2020
Task executed at time: Sun Jun 28 22:54:06 IST 2020
Task executed at time: Sun Jun 28 22:54:09 IST 2020
Task executed at time: Sun Jun 28 22:54:12 IST 2020

使用 scheduleAtFixedRate(task,delay,period) 安排任务

在这里，我们以 1 秒的周期间隔延迟 2 秒后开始执行任务。由于另一个线程执行休眠了 3 秒，Java 计时器执行任务 3 秒。由于 1 秒的间隔涵盖在此睡眠限制内，因此下一个线程执行立即开始，没有任何延迟。

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
public class TimerFixedRateDemo {
  public static void main(String[] args) {
    Timer t = new Timer();
    TimerTask task = new TimerTask() {
      int i=1;
      public void run()
      {
        System.out.println("Task executed at time: " + new Date());
        try {
          Thread.sleep(3000);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        if(i==5)
          t.cancel();
        i=i+1;
      }
    };
    System.out.println("Current time: " + new Date());
    t.scheduleAtFixedRate(task, 2000, 1000);
  }
}

输出

Current time: Sun Jun 28 22:55:59 IST 2020
Task executed at time: Sun Jun 28 22:56:01 IST 2020
Task executed at time: Sun Jun 28 22:56:04 IST 2020
Task executed at time: Sun Jun 28 22:56:07 IST 2020
Task executed at time: Sun Jun 28 22:56:10 IST 2020
Task executed at time: Sun Jun 28 22:56:13 IST 2020

 

创建自己的 Java TimerTask 类

我们可以通过扩展抽象类TimerTask来创建自己的 TimerTask 类，如下例所示。每个 TimerTask 抽象类都有一个run方法，我们需要重写它来执行任何操作。在下面的示例中，Java Timer 每秒执行一次任务，5 秒后，任务执行取消并停止。

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
public class TimerTaskDemo extends TimerTask {
  public void run() {
    System.out.println("Executing task from my own timer task class");
  }
  public static void main(String[] args) throws InterruptedException {
    Timer t = new Timer();
    TimerTask task = new TimerTaskDemo();
    
    t.schedule(task, new Date(),1000);
    Thread.sleep(5000);
    t.cancel();
    System.out.println("Timer cancelled");
  }
  
}

输出

Executing task from my own timer task class
Executing task from my own timer task class
Executing task from my own timer task class
Executing task from my own timer task class
Executing task from my own timer task class
Timer cancelled