2. 程式人生 > >Java多執行緒18：定時器Timer

Java多執行緒18：定時器Timer

阿新 • • 發佈：2019-01-02

前言

         定時/計劃功能在Java應用的各個領域都使用得非常多，比方說Web層面，可能一個專案要定時採集話單、定時更新某些快取、定時清理一批不活躍使用者等等。定時計劃任務功能在Java中主要使用的就是Timer物件，它在內部使用多執行緒方式進行處理，所以它和多執行緒技術關聯還是相當大的。那和ThreadLocal一樣，還是先講原理再講使用，Timer的實現原理不難，就簡單掃一下就好了。

1.Timer的schedule(TimeTask task, Date time)的使用

該方法的作用是在執行的日期執行一次任務

private static Timer timer = new Timer();
    
static public class MyTask extends TimerTask
{
    public void run()
    {
        System.out.println("運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTask task = new MyTask();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString = "2015-10-6 12:14:00";
    Date dateRef = sdf.parse(dateString);
    System.out.println("字串時間：" + dateRef.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(task, dateRef);
}

看一下執行效果：

字串時間：2015-10-6 12:14:00 當前時間：2015-10-6 12:13:23
運行了！時間為：Tue Oct 06 12:14:00 CST 2015

執行時間和但前時間不一致，而是和dateRef的時間一直，證明了未來執行。任務雖然執行完了，但程序沒有銷燬，控制檯上的方框可以看到還是紅色的，看下Timer的原始碼：

public Timer() {
    this("Timer-" + serialNumber());
}
public Timer(String name) {
    thread.setName(name);
    thread.start();
}

     所以，啟動一個Timer就是啟動一個新執行緒，但是這個新執行緒並不是守護執行緒，所以它會一直執行。要執行完就讓程序停止的話，設定Timer為守護執行緒就好了，有專門的建構函式可以設定：

public Timer(boolean isDaemon) {
    this("Timer-" + serialNumber(), isDaemon);
}
public Timer(String name, boolean isDaemon) {
    thread.setName(name);
    thread.setDaemon(isDaemon);
    thread.start();
}

2、計劃時間早於當前時間：立即執行

如果執行任務的時間早於當前時間，那麼立即執行task的任務：

private static Timer timer = new Timer();
    
static public class MyTask extends TimerTask
{
    public void run()
    {
        System.out.println("運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTask task = new MyTask();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString = "2014-10-6 12:14:00";
    Date dateRef = sdf.parse(dateString);
    System.out.println("字串時間：" + dateRef.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(task, dateRef);
}
字串時間：2014-10-6 12:14:00 當前時間：2015-10-6 12:20:10
運行了！時間為：Tue Oct 06 12:20:10 CST 2015

執行時間和當前時間一致，證明了立即執行

3、多個TimerTask任務執行

Timer中允許有多個任務：

private static Timer timer = new Timer();
    
static public class MyTask extends TimerTask
{
    public void run()
    {
        System.out.println("運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTask task1 = new MyTask();
    MyTask task2 = new MyTask();
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString1 = "2015-10-6 12:26:00";
    String dateString2 = "2015-10-6 12:27:00";
    Date dateRef1 = sdf1.parse(dateString1);
    Date dateRef2 = sdf2.parse(dateString2);
    System.out.println("字串時間：" + dateRef1.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    System.out.println("字串時間：" + dateRef2.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(task1, dateRef1);
    timer.schedule(task2, dateRef2);
}

看一下執行結果：

字串時間：2015-10-6 12:26:00 當前時間：2015-10-6 12:25:38
字串時間：2015-10-6 12:27:00 當前時間：2015-10-6 12:25:38
運行了！時間為：Tue Oct 06 12:26:00 CST 2015
運行了！時間為：Tue Oct 06 12:27:00 CST 2015

    可以看到，執行時間和設定的時間一致，證明了未來可以執行多個任務。另外注意，Task是以佇列的方式一個一個被順序執行的，所以執行的時間有可能和預期的時間不一致，因為前面的任務可能消耗過長，後面任務的執行時間也有可能被延遲。

      程式碼就不寫了，舉個例子，任務1計劃12:00:00被執行，任務2計劃12:00:10被執行，結果任務1執行了30秒，那麼任務2將在12:00:30被執行，因為Task是被放入佇列中的，因此必須一個一個順序執行。

Timer的schedule(TimerTask task, Date firstTime, long period)

     該方法的作用是在指定的日期之後，按指定的間隔週期性地無限迴圈地執行某一任務

  1. 計劃時間晚於當前時間：未來執行
static public class MyTask extends TimerTask
{
    public void run()
    {
        System.out.println("運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTask task = new MyTask();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString = "2015-10-6 18:00:00";
    Timer timer = new Timer();
    Date dateRef = sdf.parse(dateString);
    System.out.println("字串時間：" + dateRef.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(task, dateRef, 4000);
}

看一下執行結果：

字串時間：2015-10-6 18:01:00 當前時間：2015-10-6 18:00:15
運行了！時間為：Tue Oct 06 18:01:00 CST 2015
運行了！時間為：Tue Oct 06 18:01:04 CST 2015
運行了！時間為：Tue Oct 06 18:01:08 CST 2015
運行了！時間為：Tue Oct 06 18:01:12 CST 2015
...

看到從設定的時間開始，每隔4秒列印一次，無限列印下去

2、計劃時間早於當前時間：立即執行

static public class MyTask extends TimerTask
{
    public void run()
    {
        System.out.println("運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTask task = new MyTask();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString = "2014-10-6 18:01:00";
    Timer timer = new Timer();
    Date dateRef = sdf.parse(dateString);
    System.out.println("字串時間：" + dateRef.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(task, dateRef, 4000);
}

看一下執行結果：

字串時間：2014-10-6 18:01:00 當前時間：2015-10-6 18:02:46
運行了！時間為：Tue Oct 06 18:02:46 CST 2015
運行了！時間為：Tue Oct 06 18:02:50 CST 2015
運行了！時間為：Tue Oct 06 18:02:54 CST 2015
運行了！時間為：Tue Oct 06 18:02:58 CST 2015
運行了！時間為：Tue Oct 06 18:03:02 CST 2015
...

看到執行時間比當前時間早，從當前時間開始，每隔4秒列印一次，無限迴圈下去

TimerTask的cancel()方法

static public class MyTaskA extends TimerTask
{
    public void run()
    {
        System.out.println("A運行了！時間為：" + new Date());
        this.cancel();
    }
}
    
static public class MyTaskB extends TimerTask
{
    public void run()
    {
        System.out.println("B運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTaskA taskA = new MyTaskA();
    MyTaskB taskB = new MyTaskB();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString = "2015-10-6 18:10:00";
    Timer timer = new Timer();
    Date dateRef = sdf.parse(dateString);
    System.out.println("字串時間：" + dateRef.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(taskA, dateRef, 4000);
    timer.schedule(taskB, dateRef, 4000);    
}

看一下執行結果：

字串時間：2015-10-6 18:10:00 當前時間：2015-10-6 18:09:47
A運行了！時間為：Tue Oct 06 18:10:00 CST 2015
B運行了！時間為：Tue Oct 06 18:10:00 CST 2015
B運行了！時間為：Tue Oct 06 18:10:04 CST 2015
B運行了！時間為：Tue Oct 06 18:10:08 CST 2015
B運行了！時間為：Tue Oct 06 18:10:12 CST 2015
...

看到TimeTask的cancel()方法是將自身從任務佇列中被移除，其他任務不受影響

Timer的cancel()方法

把上面程式碼改動一下：

private static Timer timer = new Timer();
    
static public class MyTaskA extends TimerTask
{
    public void run()
    {
        System.out.println("A運行了！時間為：" + new Date());
        timer.cancel();
    }
}
    
static public class MyTaskB extends TimerTask
{
    public void run()
    {
        System.out.println("B運行了！時間為：" + new Date());
    }
}
    
public static void main(String[] args) throws Exception
{
    MyTaskA taskA = new MyTaskA();
    MyTaskB taskB = new MyTaskB();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateString = "2015-10-6 18:10:00";
    Date dateRef = sdf.parse(dateString);
    System.out.println("字串時間：" + dateRef.toLocaleString() + " 當前時間：" + new Date().toLocaleString());
    timer.schedule(taskA, dateRef, 4000);
    timer.schedule(taskB, dateRef, 4000);
}

看一下執行結果：

字串時間：2015-10-6 18:10:00 當前時間：2015-10-6 18:14:15
A運行了！時間為：Tue Oct 06 18:14:15 CST 2015

       全部任務都被清除，並且程序被銷燬。不過注意一下，cancel()方法未必一定會停止執行計劃任務，可能正常執行，因為cancel()方法會嘗試去獲取queue鎖，如果並沒有獲取到queue鎖的話，TimerTask類中的任務繼續執行也是完全有可能的

其他方法

再列舉一些Timer中的其他schedule的過載方法的作用，就不提供證明的程式碼了，可以自己嘗試一下：

1、schedule(TimerTask task, long delay)

以當前時間為參考，在此時間基礎上延遲指定的毫秒數後執行一次TimerTask任務

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

以當前時間為參考，在此時間基礎上延遲指定的毫秒數後，以period為迴圈週期，迴圈執行TimerTask任務

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

在延時的場景下，schedule方法和scheduleAtFixedRate方法沒有區別，它們的區別只是在非延時上。如果執行任務的時間沒有被延時，對於schedule方法來說，下一次任務執行的時間參考的是上一次任務的開始時間來計算的；對於scheduleAtFixedRate方法來說，下一次任務執行的時間參考的是上一次任務的結束時間來計算的

相關推薦

Java多執行緒18：定時器Timer

前言          定時/計劃功能在Java應用的各個領域都使用得非常多，比方說Web層面，可能一個專案要定時採集話單、定時更新某些快取、定時清理一批不活躍使用者等等。定時計劃任務功能在Java中主要使用的就是Timer物件，它在內部使用多執

《Java》Java“定時器和多執行緒”實際應用——定時器配合多執行緒

一、任務目標     完成一個java application應用程式，此應用程式公共類有一個double型類屬性（變數）x，初始值為0；在應用程式主程序中新開兩個執行緒，這兩個執行緒都進行死迴圈；第1個執行緒每隔300ms啟用一次，令類屬性x自加1.0並輸出顯示；第2個執行緒每隔400

java多執行緒系列：通過對戰遊戲學習CyclicBarrier

CyclicBarrier是java.util.concurrent包下面的一個工具類，字面意思是可迴圈使用（Cyclic）的屏障（Barrier），通過它可以實現讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，所有被屏障攔截的執

Java多執行緒8：synchronized鎖重入

synchronized方法/塊的內部呼叫本類的其他synchronized方法/時，是可得到鎖的。 關鍵字synchronized擁有鎖重入的功能，也就是在使用synchronized時，當一個執行緒

Java多執行緒10：同步不具有繼承性

父類的同步操作子類是不可以繼承獲得的 package unit2; public class Demo8_tongbubujujichengxing { public static void m

Java多執行緒11：多執行緒同步操作

什麼情況下需要同步 1、當多執行緒併發，有多段程式碼同時執行時，有時希望某一段程式碼執行的過程中CPU不要切換到其他執行緒工作。這時就需要執行緒同步。 2、如果兩段程式碼是同步的，那麼同一段時間只能執行

Java多執行緒12：多執行緒的死鎖

Java執行緒死鎖是一個經典的多執行緒問題，因為不同的執行緒都在等待根本不可能被釋放的鎖，從而導致所有的任務都無法繼續完成。在多執行緒技術中，“死鎖”是必須避免的，因為這會造成執行緒的“假死”。 pac

Java多執行緒16：使用ReentrantLock類實現同步操作

在Java多執行緒中，可以使用synchronized關鍵字來實現執行緒之間同步互斥，但在JDK1.5中新增加了ReentrantLock類也能達到同步的效果，並且在擴充套件功能上也更加強大。 pack

Java多執行緒19：ReentrantReadWriteLock類

類ReentrantLock具有完全互斥排他的效果，即同一時間只有一個執行緒在執行ReentrantLock.lock()方法後面的任務。這樣做雖然保證了例項變數的執行緒安全性，但效率確是非常低下的。所

Java多執行緒22：

Java中執行緒的狀態分為6種。 1.初始(NEW)：新建立了一個執行緒物件，但還沒有呼叫start()方法。 2.執行(RUNNABLE)：Java執行緒中將就緒（ready）和執行中（running）兩種狀態籠統的稱為“執行”。執行緒物件建立後，其他執行緒(

Java多執行緒24：使執行緒具有有序性

正常的情況下，執行緒的執行時多個執行緒之間執行任務的時機是無序的。可以通過改造程式碼的方式使他們執行具有有序性。 程式碼如下： package unit7; public class Demo10_R

java多執行緒4：關鍵字volatile

java多執行緒4：關鍵字volatile a.volatile關鍵字的作用： 使用volatile關鍵字增加了例項變數在多個執行緒之間的可見性。 如果沒有使用這個關鍵字，出現如下現象： 這個時候就是私有堆疊和公共堆疊的值不同步。如果改變了公共堆疊中的值後，私有的依舊沒有

java多執行緒3：關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼或者方法（函式）當作鎖

java多執行緒3：關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼或者方法（函式）當作鎖 a.當多個執行緒訪問同一個物件的時候，哪個執行緒先執行帶synchronized關鍵字的方法，哪個執行緒就該方法所屬物件的鎖Lock，那麼其他物件就智慧呈等待狀態。但是如果多個執行緒訪

java多執行緒2：區域性變數的執行緒安全，實列變數的非執行緒安全

java多執行緒2：區域性變數的執行緒安全，實列變數的非執行緒安全 “非執行緒安全“就是在多個執行緒訪問同一個物件的例項變數進行併發訪問時候發生，產生的後果就是”髒讀“，也就是取到的資料其實是被修改過的。 a.多執行緒訪問區域性變數是執行緒安全的。 package multiThread

java多執行緒1：執行緒呼叫具有隨機性，cpu執行哪個執行緒具有不確定性

java多執行緒1： a.執行緒呼叫具有隨機性，cpu執行哪個執行緒具有不確定性 在使用多執行緒技術時，多執行緒的執行結果和多執行緒的執行順序或者呼叫順序是無關的。 執行緒是一個子任務，cup以不確定的方式，或者說是以隨機的時間來呼叫執行緒中的run方法。   下邊測試

Java多執行緒20：多執行緒下的其他元件之CyclicBarrier、Callable、Future和FutureTask

CyclicBarrier         接著講多執行緒下的其他元件，第一個要講的就是CyclicBarrier。CyclicBarrier從字面理解是指迴圈屏障，它可以協同多個執行緒，讓多個執行緒在這個屏障前等待，直到所有執行緒都達到了這個屏障時，再一

Java多執行緒19：多執行緒下的其他元件之CountDownLatch、Semaphore、Exchanger

前言       在多執行緒環境下，JDK給開發者提供了許多的元件供使用者使用（主要在java.util.concurrent下），使得使用者不需要再去關心在具體場景下要如何寫出同時兼顧執行緒安全性與高效率的程式碼。之前講過的執行緒池、BlockingQueue都是

Java多執行緒17：執行緒池

使用執行緒池與不使用執行緒池的差別 先來看一下使用執行緒池與不使用執行緒池的差別，第一段程式碼是使用執行緒池的： public static void main(String[] args) { long startTime = System.currentTimeMillis();

Java多執行緒16：中斷機制

概述        之前講解Thread類中方法的時候，interrupt()、interrupted()、isInterrupted()三個方法沒有講得很清楚，只是提了一下。現在把這三個方法同一放到這裡來講，因為這三個方法都涉及到多執行緒的一個知識點--

java多執行緒系列：Executors框架

Executor介面介紹ExecutorService常用介面介紹建立執行緒池的一些方法介紹3.1 newFixedThreadPool方法3.2 newCachedThreadPool方法3.3 newScheduledThreadPool方法疑問解答4.1. Runabl