1. 定時器——基礎

Timer和TimerTask是我們用來在后臺線程中調度任務的 java util 類。基本上，TimerTask是要執行的任務，Timer是調度程序。

2.安排一次任務

(1)在給定的延遲之后

讓我們從在Timer的幫助下簡單地運行單個任務開始：

@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)調用以允許 Timer 的線程在 Junit 測試停止執行之前運行任務。

(2)在給定的日期和時間

現在讓我們看一下Timer#schedule(TimerTask, Date)方法，它的第二個參數是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);
    }
}

為簡單起見，我們用String的List來 表示這兩個數據庫。簡而言之，我們的遷移包括將第一個列表中的數據放入第二個列表中。

要在所需的時刻執行此遷移，我們必須使用 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類提供了多種可能性。我們可以設置重復以觀察固定延遲或固定速率。

固定延遲意味著執行將在最后一次執行開始后的一段時間內開始，即使它被延遲(因此本身被延遲)。

假設我們希望每兩秒安排一次任務，第一次執行需要一秒鐘，第二次執行需要兩秒鐘，但會延遲一秒鐘。然后第三次執行從第五秒開始：

0s     1s    2s     3s           5s
|--T1--|
|-----2s-----|--1s--|-----T2-----|
|-----2s-----|--1s--|-----2s-----|--T3--|

另一方面，固定速率意味著每次執行都將遵循初始計劃，無論之前的執行是否已延遲。

讓我們重用之前的示例。在固定速率下，第二個任務將在三秒后開始(由于延遲)，但第三個任務將在四秒后開始(尊重每兩秒執行一次的初始計劃)：

0s     1s    2s     3s    4s
|--T1--|       
|-----2s-----|--1s--|-----T2-----|
|-----2s-----|-----2s-----|--T3--|

現在我們已經介紹了這兩個原則，讓我們看看如何使用它們。

為了使用固定延遲調度，還有兩個schedule()方法的重載，每個都采用一個額外的參數來說明以毫秒為單位的周期。

為什么要重載兩次?因為仍然有可能在某個時刻或某個延遲后開始任務。

至于固定速率調度，我們有兩個 scheduleAtFixedRate()方法，它們也以毫秒為單位。同樣，我們有一種方法可以在給定的日期和時間啟動任務，另一種方法可以在給定的延遲后啟動它。

同樣值得一提的是,如果一個任務需要更多的時間來執行,它延遲整個鏈的執行,我們是否使用固定的延遲或固定利率。

(1)與一個固定的延遲

現在讓我們想象我們要實現一個通訊系統,每周發送電子郵件到我們的追隨者。在這種情況下,重復性任務似乎是理想的。

我們計劃每秒鐘通訊,基本上是垃圾郵件,但是發送是假的,我們好了。

首先,我們將設計一個NewsletterTask:

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

正如我們所見，每次執行之間至少間隔一秒，但有時會延遲一毫秒。這種現象是由于我們決定使用固定延遲重復。

(2)固定利率

現在，如果我們要使用固定速率重復呢?然后我們將不得不使用scheduleAtFixedRate()方法：

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

這一次，執行不會被之前的延遲：

Email sent at: 2020-01-01T10:55:03.805
Email sent at: 2020-01-01T10:55:04.805
Email sent at: 2020-01-01T10:55:05.805
Email sent at: 2020-01-01T10:55:06.805

(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.取消Timer和TimerTask

可以通過幾種方式取消任務的執行。

(1)在Run中取消TimerTask

第一個選項是在TimerTask本身的run()方法實現中調用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);
}

(2)取消定時器

另一種選擇是在Timer對象上調用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(); 
}

(3)在Run中停止TimerTask的線程

我們也可以在任務的run方法中停止線程，從而取消整個任務：

@Test
public void givenUsingTimer_whenStoppingThread_thenTimerTaskIsCancelled() 
  throws InterruptedException {
    TimerTask task = new TimerTask() {
        public void run() {
            System.out.println("Task performed on " + new Date());
            // TODO: stop the thread here
        }
    };
    Timer timer = new Timer("Timer");    
    timer.scheduleAtFixedRate(task, 1000L, 1000L);    
    Thread.sleep(1000L * 2); 
}

注意run實現中的 TODO 指令;為了運行這個簡單的例子，我們需要真正停止線程。

在現實世界的自定義線程實現中，應該支持停止線程，但在這種情況下，我們可以忽略棄用并在 Thread 類本身上使用簡單的停止API。

5. 計時器vs 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();
}

那么Timer和ExecutorService解決方案的主要區別是什么：

定時器可以對系統時鐘的變化敏感;ScheduledThreadPoolExecutor不是。

Timer只有一個執行線程;ScheduledThreadPoolExecutor可以配置任意數量的線程。

TimerTask中拋出的運行時異常會殺死線程，因此以下計劃任務不會進一步運行;使用ScheduledThreadExecutor，當前任務將被取消，但其余任務將繼續運行。