java實現多線程之定時器任務。本站提示廣大學習愛好者：（java實現多線程之定時器任務）文章只能為提供參考，不一定能成為您想要的結果。以下是java實現多線程之定時器任務正文
在Java中Timer是java.util包中的一個工具類，提供了定時器的功能。我們可以創建一個Timer對象，然後調用其schedule方法在某個特定的時間去執行一個特定的任務。並且你可以讓其以特定頻率一直執行某個任務，這個任務是用TimerTask來描述的，我們只需要將要進行的操作寫在TimerTask類的run方法中即可。先附上兩個小例子一遍讓讀者了解什麼是定時器。接著再分析其中的一些源碼實現。
第一個小例子：
package com.zkn.newlearn.thread;
import java.util.Timer;
import java.util.TimerTask;
/**
* 傳統的定時器
* Created by zkn on 2016/11/1.
*/
public class TraditionalTimerTest01 {
public static void main(String[] args){
//TimerTask是Runnable接口的一個實現類是，它是一個抽像類
//schedule是一個重載方法：第一個參數TimerTask的實現類。
// 第二個參數是第一次執行的時間。
// 第三個參數是間隔時間
new Timer().schedule(new TimerTask() {
@Override
public void run() {
System.out.println("這是一個定時器任務!");
}
},1000,2000);
}
}
第二個小例子：讓任務1每隔4秒執行，讓任務2每隔2秒執行。依次反復。
package com.zkn.newlearn.thread;
import java.util.Timer;
import java.util.TimerTask;
/**
* Created by zkn on 2016/11/1.
*/
public class TraditionalTimerTest02 {
public static void main(String[] args){
new Timer().schedule(new MyTimerTask01(),4000);
}
private static class MyTimerTask01 extends TimerTask{
@Override
public void run() {
System.out.println("我是TimerTask1，我被執行了!");
new Timer().schedule(new MyTimerTask02(),2000);
}
}
private static class MyTimerTask02 extends TimerTask {
@Override
public void run() {
System.out.println("我是TimerTask2，我被執行了!");
new Timer().schedule(new MyTimerTask01(),4000);
}
}
}
大家一定會很好奇定時器是怎麼執行的？接下來我們來看一下Timer中的主要代碼。
private final TaskQueue queue = new TaskQueue(); /** * The timer thread. */ private final TimerThread thread = new TimerThread(queue);
注意著兩段代碼是很重要的兩段代碼。TaskQueue和TimerThread都是Timer的內部類。TaskQueue是一個執行任務的優先隊列。TimerThread是一個繼承了Thread的線程類。他們兩個在定時器中起著至關重要的作用，定時器基本上就是靠這兩個類支撐的。 接下來我們來一下Timer的構造方法：
public Timer(String name) {
thread.setName(name);
thread.start();
}
public Timer() {
this("Timer-" + serialNumber());
}
無參的這個構造函數會調用這個有參的構造函數，在這個有參的構造函數中你看到了什麼？thread.start()看著是不是很眼熟啊？沒錯，在new Timer()的時候，就是啟動了一個線程。而啟動這個線程的對象就是上面的TimerThread！接下來我們來看一下TimerThread的run方法中干了些什麼：
public void run() {
try {
mainLoop();
} finally {
// Someone killed this Thread, behave as if Timer cancelled
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear(); // Eliminate obsolete references
}
}
}
這個run方法中主要是干了兩件事：一：調用mainLoop()這個死循環的方法，我們在下面會詳細分析；二：finally代碼塊終止定時任務。終止定時任務的這個沒什麼說的，我們主要來看一下mainLoop()這個方法。
private void mainLoop() {
while (true) { // 開始死循環
try {
TimerTask task;
boolean taskFired;
synchronized(queue) {
// 如果任務隊列中為空並且定時任務沒有被取消話，線程被掛起 等待執行任務的到來
while (queue.isEmpty() && newTasksMayBeScheduled)
queue.wait();
if (queue.isEmpty())
break; // 如果任務隊列中沒有任務了，則結束循環結束任務
// 如果隊列中有執行任務的話，接著往下走
long currentTime, executionTime;
task = queue.getMin();
synchronized(task.lock) {
if (task.state == TimerTask.CANCELLED) {
queue.removeMin();
continue; // 如果執行任務被取消的話 則移除當前任務。這裡會重新排隊列裡的任務執行順序
}
currentTime = System.currentTimeMillis();
executionTime = task.nextExecutionTime;
if (taskFired = (executionTime<=currentTime)) {
if (task.period == 0) { // 如果只執行一次的話，則在執行完之後，結束執行任務
queue.removeMin();
task.state = TimerTask.EXECUTED;
} else { // 如果是固定頻率執行任務的話，則計算下次執行的時間
queue.rescheduleMin(
task.period<0 ? currentTime - task.period
: executionTime + task.period);
}
}
}
if (!taskFired) // 不到任務執行的時候 等待線程調用
queue.wait(executionTime - currentTime);
}
if (taskFired) // 任務執行時間到，調用任務的run方法，執行任務
task.run();
} catch(InterruptedException e) {
}
}
}
這個類比較長，具體的執行操作我在注釋裡都標注了。這個類基本上干了這樣幾件事：循環調用任務隊列中的任務，執行隊列中的任務。執行任務是什麼時候放到執行隊列中的呢?在schedule方法。我們來看看schedule的實現：
public void schedule(TimerTask task, long delay, long period) {
if (delay < 0) // 如果第一次執行的時間小於0 拋出異常
throw new IllegalArgumentException("Negative delay.");
if (period <= 0) //間隔時間小於等於 0 拋出異常
throw new IllegalArgumentException("Non-positive period.");
sched(task, System.currentTimeMillis()+delay, -period);
}
private void sched(TimerTask task, long time, long period) {
if (time < 0)
throw new IllegalArgumentException("Illegal execution time.");
// Constrain value of period sufficiently to prevent numeric
// overflow while still being effectively infinitely large.這個間隔時間到死基本上也執行不到
if (Math.abs(period) > (Long.MAX_VALUE >> 1))
period >>= 1;
synchronized(queue) {
if (!thread.newTasksMayBeScheduled) //在任務的執行方法中 如果定時任務已經被取消的話 則拋出異常
throw new IllegalStateException("Timer already cancelled.");
synchronized(task.lock) { //object對象鎖
if (task.state != TimerTask.VIRGIN) // 剛開是執行任務的時候 任務的狀態應該是0的
throw new IllegalStateException(
"Task already scheduled or cancelled");
task.nextExecutionTime = time; //下次執行時間 在上面的mainLoop方法中有用到
task.period = period; //設置任務的間隔時間，在上面的mainLoop方法中有用到
task.state = TimerTask.SCHEDULED; // 調度方法被調用 設置定時任務的狀態為 已調度未執行
}
queue.add(task); //把執行任務加入到任務隊列中
if (queue.getMin() == task)
queue.notify(); // 如果任務隊列中的第一個任務為當前任務的話，則把當前任務放入到等鎖池中 等待執行
}
}
shedule這個方法做的事情比較簡單。最主要的作用是把TimerTask放到任務隊列中。
下面我們大致看一下TaskQueue的代碼：
class TaskQueue {
//定義一個TimerTask的堆數組 <span > </span>
private TimerTask[] queue = new TimerTask[128];
//任務隊列中的任務數<span > </span>
private int size = 0;
int size() {
return size;
}
//添加任務到優先隊列中 如果數組的長度不夠的話會擴展數組
void add(TimerTask task) {
// Grow backing store if necessary
if (size + 1 == queue.length)
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task;
fixUp(size);
}
//獲取優先執行的任務
TimerTask getMin() {
return queue[1];
}
TimerTask get(int i) {
return queue[i];
}
//移除掉排在第一位的不能執行的任務
void removeMin() {
queue[1] = queue[size];
queue[size--] = null; // Drop extra reference to prevent memory leak 把對象置空 等待gc回收
fixDown(1);
}
//刪除任務隊列隊列中的任務 這裡用來一個斷言 來判斷 i 不能大於 size
void quickRemove(int i) {
assert i <= size;
queue[i] = queue[size];
queue[size--] = null; // Drop extra ref to prevent memory leak
}
//重新設置優先執行任務的執行時間 並對任務隊列進行重新排序 以確保最優先的任務 優先被執行
void rescheduleMin(long newTime) {
queue[1].nextExecutionTime = newTime;
fixDown(1);
}
boolean isEmpty() {
return size==0;
}
//清空任務隊列 定時任務結束
void clear() {
// Null out task references to prevent memory leak
for (int i=1; i<=size; i++)
queue[i] = null;
size = 0;
}
//兩個堆排序 選出最優先的執行任務
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;
}
}
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);
}
}
OK，到這裡定時任務的源碼大致分析完畢。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持。
