Java定時器Timer的源碼分析

更新時間：2022年11月02日 11:09:42 作者：UnicornLien

通過源碼分析，我們可以更深入的了解其底層原理。本文將通過Timer的源碼，帶大家深入了解Java?Timer的使用，感興趣的小伙伴可以了解一下

一、TimerTask

TimerTask是一個任務抽象類，實現(xiàn)了Runnable接口，是可被線程執(zhí)行的。

1. 任務狀態(tài)

在TimerTask中定義了關(guān)于任務狀態(tài)的常量字段：

//	未調(diào)度狀態(tài)
static final int VIRGIN = 0;
//	任務已調(diào)度，但未執(zhí)行
static final int SCHEDULED   = 1;
//	若是一次性任務表示已執(zhí)行；可重復執(zhí)行任務，該狀態(tài)無效
static final int EXECUTED    = 2;
//	任務被取消
static final int CANCELLED   = 3;

當一個TimerTask對象創(chuàng)建后，其初始狀態(tài)為VIRGIN；

當調(diào)用Timer的schedule方法調(diào)度了此TimerTask對象后，其狀態(tài)變更為SCHEDULED；

如果TimerTask是一次性任務，此任務執(zhí)行后，狀態(tài)將變?yōu)镋XECUTED，可重復執(zhí)行任務執(zhí)行后狀態(tài)不變；

當中途調(diào)用了TimerTask.cancel方法，該任務的狀態(tài)將變?yōu)镃ANCELLED。

2. 任務屬性說明

TimerTask中，有如下成員變量：

//	用于加鎖控制多線程修改TimerTask內(nèi)部狀態(tài)
final Object lock = new Object();

//	任務狀態(tài)，初始狀態(tài)為待未調(diào)度狀態(tài)
int state = VIRGIN;

//	任務的下一次執(zhí)行時間點
long nextExecutionTime;

//  任務執(zhí)行的時間間隔。正數(shù)表示固定速率；負數(shù)表示固定時延；0表示只執(zhí)行一次
long period = 0;

3. 任務方法說明

TimerTask中有三個方法：

run：實現(xiàn)了Runnable接口，創(chuàng)建TimerTask需要重寫此方法，編寫任務執(zhí)行代碼
cancel：取消任務
scheduledExecutionTime：計算執(zhí)行時間點

3.1. Cancel方法

cancel方法的實現(xiàn)代碼：

public boolean cancel() {
    synchronized(lock) {
        boolean result = (state == SCHEDULED);
        state = CANCELLED;
        return result;
    }
}

在cancel方法內(nèi)，使用synchronized加鎖，這是因為Timer內(nèi)部的線程會對TimerTask狀態(tài)進行修改，而調(diào)用cancel方法一般會是另外一個線程。

為了避免線程同步問題，cancel在修改狀態(tài)前進行了加鎖操作。

調(diào)用cancel方法將會把任務狀態(tài)變更為CANCELLED狀態(tài)，即任務取消狀態(tài)，并返回一個布爾值，該布爾值表示此任務之前是否已是SCHEDULED 已調(diào)度狀態(tài)。

3.2. scheduledExecutionTime方法

scheduledExecutionTime方法實現(xiàn)：

public long scheduledExecutionTime() {
    synchronized(lock) {
        return (period < 0 ? nextExecutionTime + period
                           : nextExecutionTime - period);
    }
}

該方法返回此任務的下次執(zhí)行時間點。

二、Timer

分析Timer源代碼，Timer在內(nèi)部持有了兩個成員變量：

private final TaskQueue queue = new TaskQueue();

private final TimerThread thread = new TimerThread(queue);

TaskQueue是任務隊列，TimerThread是任務處理線程。

1. sched方法

無論是使用schedule還是scheduleAtFixedRate方法來調(diào)度任務，Timer內(nèi)部最后都是調(diào)用sched方法進行處理。

public void schedule(TimerTask task, Date time) {
    sched(task, time.getTime(), 0);	//	一次性任務，period為0
}

public void schedule(TimerTask task, long delay) {
    ...
    sched(task, System.currentTimeMillis()+delay, 0);	//	一次性任務，period為0
}

public void schedule(TimerTask task, long delay, long period) {
    ...
    sched(task, System.currentTimeMillis()+delay, -period);	//	固定延時模式，-period
}

public void schedule(TimerTask task, Date firstTime, long period) {
    ...
    sched(task, firstTime.getTime(), -period);	//	固定延時模式，-period
}

public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
    ...
    sched(task, System.currentTimeMillis()+delay, period);	//	固定速率模式，period為正
}

public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) {
    ...
    sched(task, firstTime.getTime(), period);	//	固定速率模式，period為正
}

sched方法核心代碼：

private void sched(TimerTask task, long time, long period) {
   ...

    //	加鎖，避免外部其他線程同時調(diào)用cancel，同時訪問queue產(chǎn)生線程同步問題
    synchronized(queue) {

        //	如果線程已終止，拋出異常
        if (!thread.newTasksMayBeScheduled)
            throw new IllegalStateException("Timer already cancelled.");

        //	加鎖，避免多線程訪問同一個任務產(chǎn)生線程同步問題
        synchronized(task.lock) {
            
            //	task的狀態(tài)必須為VIRGIN，否則認為已經(jīng)加入調(diào)度或者已經(jīng)取消了，避免重復的調(diào)度
            if (task.state != TimerTask.VIRGIN)
                throw new IllegalStateException(
                    "Task already scheduled or cancelled");
            
            //	設置下次執(zhí)行時間點
            task.nextExecutionTime = time;
            //	設置時間間隔
            task.period = period;
            //	任務狀態(tài)變更為已調(diào)度
            task.state = TimerTask.SCHEDULED;
        }

        //	將任務添加到隊列中
        queue.add(task);
        
    	//	如果此任務是最近的任務，喚醒線程
        if (queue.getMin() == task)
            queue.notify();
    }
}

2. cancel方法

cancel方法一般是由外部其他線程調(diào)用，而Timer內(nèi)部的線程也會對任務隊列進行操作，因此加鎖。

public void cancel() {
    synchronized(queue) {
        //	修改線程的循環(huán)執(zhí)行標志，令線程能夠終止
        thread.newTasksMayBeScheduled = false;
        //	清空任務隊列
        queue.clear();
        //	喚醒線程
        queue.notify();
    }
}

3. purge方法

當通過TimerTask.cancel將任務取消后，Timer的任務隊列還引用著此任務，Timer只有到了要執(zhí)行時才會移除，其他時候并不會自動將此任務移除，需要調(diào)用purge方法進行清理。

public int purge() {
     int result = 0;

     synchronized(queue) {
         
         //	遍歷隊列，將CANCELLED狀態(tài)的任務從任務隊列中移除
         for (int i = queue.size(); i > 0; i--) {
             if (queue.get(i).state == TimerTask.CANCELLED) {
                 queue.quickRemove(i);
                 result++;
             }
         }

         //	如果移除任務數(shù)不為0，觸發(fā)重新排序
         if (result != 0)
             queue.heapify();
     }

    //	返回移除任務數(shù)
     return result;
 }

三、TaskQueue

TaskQueue是Timer類文件中封裝的一個隊列數(shù)據(jù)結(jié)構(gòu)，內(nèi)部默認是一個長度128的TimerTask數(shù)組，當任務加入時，檢測到數(shù)組將滿將會自動擴容1倍，并對數(shù)組元素根據(jù)下次執(zhí)行時間nextExecutionTime按時間從近到遠進行排序。

void add(TimerTask task) {
    // 檢測數(shù)組長度，若不夠則進行擴容
    if (size + 1 == queue.length)
        queue = Arrays.copyOf(queue, 2*queue.length);

	//	任務入隊
    queue[++size] = task;

	//	排序
    fixUp(size);
}

fixUp方法實現(xiàn)：

private void fixUp(int k) {
    while (k > 1) {
        int j = k >> 1;
        if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
            break;
        TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
        k = j;
    }
}

TaskQueue中除了fixUp方法外還有一個fixDown方法，這兩個其實就是堆排序算法，在算法專題中再進行詳細介紹，只要記住他們的任務就是按時間從近到遠進行排序，最近的任務排在隊首即可。

private void fixDown(int k) {
    int j;
    while ((j = k << 1) <= size && j > 0) {
        if (j < size &&
            queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
            j++; // j indexes smallest kid
        if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
            break;
        TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
        k = j;
    }
}

void heapify() {
    for (int i = size/2; i >= 1; i--)
        fixDown(i);
}

四、TimerThread

TimerThread的核心代碼位于mainLoop方法：

private void mainLoop() {
    
    //	死循環(huán)，從隊列取任務執(zhí)行
    while (true) {
        try {
            TimerTask task;
            boolean taskFired;
            
            //	對任務隊列加鎖
            synchronized(queue) {
                
                //	如果隊列中沒有任務，則進入等待，newTasksMayBeScheduled是線程運行標志位，為false時將退出循環(huán)
                while (queue.isEmpty() && newTasksMayBeScheduled)
                    queue.wait();
                
                //	如果任務隊列是空的還執(zhí)行到這一步，說明newTasksMayBeScheduled為false，退出循環(huán)
                if (queue.isEmpty())
                    break; 

                long currentTime, executionTime;
                
                //	從隊列取得最近的任務
                task = queue.getMin();
                
                //	加鎖
                synchronized(task.lock) {
                    
                    //	如果任務狀態(tài)是已取消，則移除該任務，重新循環(huán)取任務
                    if (task.state == TimerTask.CANCELLED) {
                        queue.removeMin();
                        continue; 
                    }
                    
                    //	當前時間
                    currentTime = System.currentTimeMillis();
                    //	任務的執(zhí)行時間點
                    executionTime = task.nextExecutionTime;
                    
                    //	如果執(zhí)行時間點早于或等于當前時間，即過期/時間到了，則觸發(fā)任務執(zhí)行
                    if (taskFired = (executionTime<=currentTime)) {

                        //	如果任務period=0，即一次性任務
                        if (task.period == 0) {

                            //	從隊列移除一次性任務
                            queue.removeMin();


                            //	任務狀態(tài)變更為已執(zhí)行
                            task.state = TimerTask.EXECUTED;

                        } else {

                            //	可重復執(zhí)行任務，重新進行調(diào)度，period<0是固定時延，period>0是固定速率
                            queue.rescheduleMin(
                              task.period<0 ? currentTime   - task.period	//	計算下次執(zhí)行時間
                                            : executionTime + task.period);
                        }
                    }
                }
                
                // taskFired為false即任務尚未到執(zhí)行時間點，進行等待，等待時間是 執(zhí)行時間點 - 當前時間點
                if (!taskFired)
                    queue.wait(executionTime - currentTime);
            }

            //	taskFired為true表示已觸發(fā)，執(zhí)行任務
            if (taskFired)  
                task.run();
        } catch(InterruptedException e) {
        }
    }
}

以上就是Java定時器Timer的源碼分析的詳細內(nèi)容，更多關(guān)于Java Timer的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: