Analysieren Sie Timer in Java und verwenden Sie Timer, um Flipperspiele zu erstellen.

Wenn wir während unseres Programmierprozesses einige einfache geplante Aufgaben ohne komplizierte Steuerung ausführen müssen, können wir erwägen, die geplanten Timer-Aufgaben im JDK zu verwenden, um dies zu implementieren. Im Folgenden analysiert LZ den Java-Timer-Timer unter drei Aspekten: seinen Prinzipien, Beispielen und Timer-Defekten.

1. Einführung
In Java muss eine vollständige geplante Aufgabe von zwei Klassen ausgeführt werden: Timer und TimerTask. Sie sind in der API wie folgt definiert: Timer: ein Tool, mit dem Threads Aufgaben planen, die in Zukunft in Hintergrundthreads ausgeführt werden sollen. Aufgaben können so geplant werden, dass sie einmal ausgeführt werden oder sich regelmäßig wiederholen. Von TimerTask: Eine von einem Timer geplante Aufgabe zur einmaligen oder wiederkehrenden Ausführung. Wir können verstehen, dass Timer ein Timer-Tool ist, das zum Planen und Ausführen bestimmter Aufgaben in einem Hintergrundthread verwendet wird, während TimerTask eine abstrakte Klasse ist und ihre Unterklassen eine Aufgabe darstellen, die von Timer geplant werden kann.
Timer-Klasse
In der Tool-Klasse Timer stehen vier Konstruktionsmethoden zur Verfügung. Jede Konstruktionsmethode startet den Timer-Thread. Gleichzeitig kann die Timer-Klasse sicherstellen, dass mehrere Threads ein einzelnes Timer-Objekt ohne externe Synchronisierung teilen können . , daher ist die Timer-Klasse threadsicher. Da jedoch jedes Timer-Objekt einem einzelnen Hintergrundthread entspricht, der zur sequentiellen Ausführung aller Timer-Aufgaben verwendet wird, sollte die von unserem Thread benötigte Zeit für die Ausführung der Aufgabe im Allgemeinen sehr kurz sein. Aufgrund besonderer Umstände kann die Ausführung einer Timer-Aufgabe jedoch länger dauern Wenn es zu lang ist, belegt es „ausschließlich“ den Aufgabenausführungsthread des Timers und alle nachfolgenden Threads müssen warten, bis die Ausführung abgeschlossen ist, was die Ausführung nachfolgender Aufgaben verzögert und dazu führt, dass sich diese Aufgaben häufen Analyse später.
Wenn das Programm den Timer initialisiert, wird die geplante Aufgabe entsprechend der von uns festgelegten Zeit ausgeführt. Der Timer stellt die Zeitplanmethode bereit, die über mehrere Überlastungsmethoden zur Anpassung an verschiedene Situationen verfügt, wie folgt:
Schedule( TimerTask-Aufgabe , Datum/Uhrzeit): Planen Sie die Ausführung der angegebenen Aufgabe zum angegebenen Zeitpunkt.
Zeitplan (TimerTask-Aufgabe, Datum erste Zeit, langer Zeitraum): Ordnen Sie die angegebene Aufgabe so an, dass sie zum angegebenen Zeitpunkt mit der wiederholten Ausführung mit fester Verzögerung beginnt.
Zeitplan (TimerTask-Aufgabe, lange Verzögerung): Planen Sie die Ausführung der angegebenen Aufgabe nach der angegebenen Verzögerung.
Zeitplan (TimerTask-Aufgabe, lange Verzögerung, langer Zeitraum): Planen Sie die angegebene Aufgabe so, dass sie ab der angegebenen Verzögerung eine wiederholte Ausführung mit fester Verzögerung durchführt.
Gleichzeitig ist auch die Methode „scheduleAtFixedRate“ mit der Methode „scheduleAtFixedRate“ identisch, ihr Fokus ist jedoch unterschiedlich.
schemeAtFixedRate(TimerTask task, Date firstTime, long period): Planen Sie die angegebene Aufgabe so, dass sie zum angegebenen Zeitpunkt wiederholt mit fester Rate ausgeführt wird.
ScheduleAtFixedRate(TimerTask-Aufgabe, lange Verzögerung, langer Zeitraum): Planen Sie die angegebene Aufgabe so, dass sie nach der angegebenen Verzögerung mit der wiederholten Ausführung mit fester Rate beginnt.
TimerTask
Die TimerTask-Klasse ist eine abstrakte Klasse, die von Timer als Aufgabe zur einmaligen oder wiederholten Ausführung angeordnet wird. Es verfügt über eine abstrakte Methode run(), mit der die Operation ausgeführt wird, die von der entsprechenden Timer-Aufgabe ausgeführt werden soll. Daher muss jede spezifische Aufgabenklasse TimerTask erben und dann die run()-Methode überschreiben.
Darüber hinaus verfügt es über zwei nicht abstrakte Methoden:
boolean cancel(): Diese Timer-Aufgabe abbrechen.
long ScheduledExecutionTime(): Gibt die geplante Ausführungszeit der letzten tatsächlichen Ausführung dieser Aufgabe zurück.

2. Beispiel
2.1. Geben Sie die Verzögerungszeit für die Ausführung der geplanten Aufgabe an

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!!!!"); 
 } 
}

Laufendes Ergebnis:

Erster Druck:

timer begin....

Drucken nach 3 Sekunden:

Time's up!!!!

2.2. Geplante Aufgaben ausführen die angegebene Zeit

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, 11);
  calendar.set(Calendar.MINUTE, 39);
  calendar.set(Calendar.SECOND, 00);
  Date time = calendar.getTime();
    
  return time;
 }
   
 public static void main(String[] args) {
  new TimerTest02();
 }
}
  
public class TimerTaskTest02 extends TimerTask{
  
 @Override
 public void run() {
  System.out.println("指定时间执行线程任务...");
 }
}

Die Thread-Aufgabe wird ausgeführt, wenn die Zeit 11:39:00 erreicht. Natürlich wird sie auch ausgeführt, wenn sie erreicht ist ist größer als diese Zeit! ! Das Ausführungsergebnis ist:

指定时间time=Tue Jun 10 11:39:00 CST 2014
指定时间执行线程任务...

2.3 Nach der Verzögerung der angegebenen Zeit wird die geplante Aufgabe zyklisch im angegebenen Intervall ausgeführt

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);
 }
}

Laufergebnis:

本次执行该线程的时间为：Tue Jun 10 21:19:47 CST 2014
本次执行该线程的时间为：Tue Jun 10 21:19:49 CST 2014
本次执行该线程的时间为：Tue Jun 10 21:19:51 CST 2014
本次执行该线程的时间为：Tue Jun 10 21:19:53 CST 2014
本次执行该线程的时间为：Tue Jun 10 21:19:55 CST 2014
本次执行该线程的时间为：Tue Jun 10 21:19:57 CST 2014
.................

      对于这个线程任务,如果我们不将该任务停止,他会一直运行下去。
      对于上面三个实例，LZ只是简单的演示了一下，同时也没有讲解scheduleAtFixedRate方法的例子，其实该方法与schedule方法一样！
2.4、分析schedule和scheduleAtFixedRate
（1）schedule(TimerTask task, Date time)、schedule(TimerTask task, long delay)
      对于这两个方法而言，如果指定的计划执行时间scheduledExecutionTime（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的缺陷
3.1、Timer的缺陷
      Timer计时器可以定时（指定时间执行任务）、延迟（延迟5秒执行任务）、周期性地执行任务（每隔个1秒执行任务），但是，Timer存在一些缺陷。首先Timer对调度的支持是基于绝对时间的，而不是相对时间，所以它对系统时间的改变非常敏感。其次Timer线程是不会捕获异常的，如果TimerTask抛出的了未检查异常则会导致Timer线程终止，同时Timer也不会重新恢复线程的执行，他会错误的认为整个Timer线程都会取消。同时，已经被安排单尚未执行的TimerTask也不会再执行了，新的任务也不能被调度。故如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。
（1）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("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));
    try {
     Thread.sleep(4000); //线程休眠3000
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }, 1000);
 }
   
 public void timerTwo(){
  timer.schedule(new TimerTask() {
   public void run() {
    System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));
   }
  }, 3000);
 }
   
 public static void main(String[] args) throws Exception {
  TimerTest04 test = new TimerTest04();
    
  test.timerOne();
  test.timerTwo();
 }
}

   

      按照我们正常思路，timerTwo应该是在3s后执行，其结果应该是：

timerOne invoked ,the time:1001
timerOne invoked ,the time:3001

   

      但是事与愿违，timerOne由于sleep(4000)，休眠了4S，同时Timer内部是一个线程，导致timeOne所需的时间超过了间隔时间，结果：

timerOne invoked ,the time:1000
timerOne invoked ,the time:5000

   

 
（2）Timer抛出异常缺陷
如果TimerTask抛出RuntimeException，Timer会终止所有任务的运行。如下：

public class TimerTest04 {
 private Timer timer;
   
 public TimerTest04(){
  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) {
  TimerTest04 test = new TimerTest04();
  test.timerOne();
  test.timerTwo();
 }
}

   

运行结果：timerOne抛出异常，导致timerTwo任务终止。

Exception in thread "Timer-0" java.lang.RuntimeException
 at com.chenssy.timer.TimerTest04$1.run(TimerTest04.java:25)
 at java.util.TimerThread.mainLoop(Timer.java:555)
 at java.util.TimerThread.run(Timer.java:505)

   

对于Timer的缺陷，我们可以考虑 ScheduledThreadPoolExecutor 来替代。Timer是基于绝对时间的，对系统时间比较敏感，而ScheduledThreadPoolExecutor 则是基于相对时间；Timer是内部是单一线程，而ScheduledThreadPoolExecutor内部是个线程池，所以可以支持多个任务并发执行。
3.2、用ScheduledExecutorService替代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();
 }
}

   

运行结果：

timerOne,the time:1003
timerTwo,the time:2005

   

（2）解决问题二

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() {
    throw new RuntimeException();
   }
  },1000,TimeUnit.MILLISECONDS);
 }
   
 public void timerTwo(){
  scheduExec.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("timerTwo invoked .....");
   }
  },2000,500,TimeUnit.MILLISECONDS);
 }
   
 public static void main(String[] args) {
  ScheduledExecutorTest test = new ScheduledExecutorTest();
  test.timerOne();
  test.timerTwo();
 }
}

   

运行结果：

timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
........................

   

四、使用定时器实现弹弹球
模拟书上的一个例题做了一个弹弹球，是在画布上的指定位置画多个圆，经过一段的延时后，在附近位置重新画。使球看起来是动，通过JSpinner组件调节延时，来控制弹弹球的移动速度.
        BallsCanvas.java

public class BallsCanvas extends Canvas implements ActionListener,
  FocusListener {
  
 private Ball balls[]; // 多个球
 private Timer timer;
  
 private static class Ball {
  int x, y; // 坐标
  Color color; // 颜色
  boolean up, left; // 运动方向
  
  Ball(int x, int y, Color color) {
   this.x = x;
   this.y = y;
   this.color = color;
   up = left = false;
  }
 }
  
 public BallsCanvas(Color colors[], int delay) { // 初始化颜色、延时
  this.balls = new Ball[colors.length];
  for (int i = 0, x = 40; i < colors.length; i++, x += 40) {
   balls[i] = new Ball(x, x, colors[i]);
  }
  this.addFocusListener(this);
  timer = new Timer(delay, this); // 创建定时器对象，delay指定延时
  timer.start();
  
 }
  
 // 设置延时
 public void setDelay(int delay) {
  timer.setDelay(delay);
 }
  
 // 在canvas上面作画
 public void paint(Graphics g) {
  for (int i = 0; i < balls.length; i++) {
   g.setColor(balls[i].color); // 设置颜色
   balls[i].x = balls[i].left ? balls[i].x - 10 : balls[i].x + 10;
   if (balls[i].x < 0 || balls[i].x >= this.getWidth()) { // 到水平方向更改方向
    balls[i].left = !balls[i].left;
   }
  
   balls[i].y = balls[i].up ? balls[i].y - 10 : balls[i].y + 10;
   if (balls[i].y < 0 || balls[i].y >= this.getHeight()) { // 到垂直方向更改方向
    balls[i].up = !balls[i].up;
   }
   g.fillOval(balls[i].x, balls[i].y, 20, 20); // 画指定直径的圆
  }
 }
  
 // 定时器定时执行事件
 @Override
 public void actionPerformed(ActionEvent e) {
  repaint(); // 重画
 }
  
 // 获得焦点
 @Override
 public void focusGained(FocusEvent e) {
  timer.stop(); // 定时器停止
  
 }
  
 // 失去焦点
 @Override
 public void focusLost(FocusEvent e) {
  timer.restart(); // 定时器重启动
  
 }
}

   

BallsJFrame.java

class BallsJFrame extends JFrame implements ChangeListener {
  
  private BallsCanvas ball;
  private JSpinner spinner;
  
  public BallsJFrame() {
   super("弹弹球");
   this.setBounds(300, 200, 480, 360);
   this.setDefaultCloseOperation(EXIT_ON_CLOSE);
   Color colors[] = { Color.red, Color.green, Color.blue,
     Color.magenta, Color.cyan };
   ball = new BallsCanvas(colors, 100);
   this.getContentPane().add(ball);
  
   JPanel panel = new JPanel();
   this.getContentPane().add(panel, "South");
   panel.add(new JLabel("Delay"));
   spinner = new JSpinner();
   spinner.setValue(100);
   panel.add(spinner);
   spinner.addChangeListener(this);
   this.setVisible(true);
  }
  
  @Override
  public void stateChanged(ChangeEvent e) {
   // 修改JSpinner值时，单击JSpinner的Up或者down按钮时，或者在JSpinner中按Enter键
   ball.setDelay(Integer.parseInt("" + spinner.getValue()));
  
  }
  
 public static void main(String[] args) {
  new BallsJFrame();
 }
  
}

   

效果如下：

解析Java中的定时器及使用定时器制作弹弹球游戏的示例