java實現(xiàn)多線程之定時器任務(wù)

更新時間：2017年02月20日 14:29:27 作者：木葉之榮

本篇文章主要介紹了java實現(xiàn)多線程之定時器任務(wù)，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

在Java中Timer是java.util包中的一個工具類，提供了定時器的功能。我們可以創(chuàng)建一個Timer對象，然后調(diào)用其schedule方法在某個特定的時間去執(zhí)行一個特定的任務(wù)。并且你可以讓其以特定頻率一直執(zhí)行某個任務(wù)，這個任務(wù)是用TimerTask來描述的，我們只需要將要進行的操作寫在TimerTask類的run方法中即可。先附上兩個小例子一遍讓讀者了解什么是定時器。接著再分析其中的一些源碼實現(xiàn)。

第一個小例子：

package com.zkn.newlearn.thread; 
 
import java.util.Timer; 
import java.util.TimerTask; 
 
/** 
 * 傳統(tǒng)的定時器 
 * Created by zkn on 2016/11/1. 
 */ 
public class TraditionalTimerTest01 { 
 
  public static void main(String[] args){ 
    //TimerTask是Runnable接口的一個實現(xiàn)類是，它是一個抽像類 
    //schedule是一個重載方法：第一個參數(shù)TimerTask的實現(xiàn)類。 
    // 第二個參數(shù)是第一次執(zhí)行的時間。 
    // 第三個參數(shù)是間隔時間 
    new Timer().schedule(new TimerTask() { 
      @Override 
      public void run() { 
 
        System.out.println("這是一個定時器任務(wù)!"); 
      } 
    },1000,2000); 
  } 
}

第二個小例子：讓任務(wù)1每隔4秒執(zhí)行，讓任務(wù)2每隔2秒執(zhí)行。依次反復(fù)。

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，我被執(zhí)行了!"); 
      new Timer().schedule(new MyTimerTask02(),2000); 
    } 
  } 
 
  private static class MyTimerTask02 extends TimerTask { 
 
    @Override 
    public void run() { 
      System.out.println("我是TimerTask2，我被執(zhí)行了!"); 
      new Timer().schedule(new MyTimerTask01(),4000); 
    } 
  } 
}

大家一定會很好奇定時器是怎么執(zhí)行的？接下來我們來看一下Timer中的主要代碼。

private final TaskQueue queue = new TaskQueue(); 
 
/** 
 * The timer thread. 
 */ 
private final TimerThread thread = new TimerThread(queue);

注意著兩段代碼是很重要的兩段代碼。TaskQueue和TimerThread都是Timer的內(nèi)部類。TaskQueue是一個執(zhí)行任務(wù)的優(yōu)先隊列。TimerThread是一個繼承了Thread的線程類。他們兩個在定時器中起著至關(guān)重要的作用，定時器基本上就是靠這兩個類支撐的。接下來我們來一下Timer的構(gòu)造方法：

public Timer(String name) { 
  thread.setName(name); 
  thread.start(); 
} 

public Timer() { 
  this("Timer-" + serialNumber()); 
}

無參的這個構(gòu)造函數(shù)會調(diào)用這個有參的構(gòu)造函數(shù)，在這個有參的構(gòu)造函數(shù)中你看到了什么？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方法中主要是干了兩件事：一：調(diào)用mainLoop()這個死循環(huán)的方法，我們在下面會詳細(xì)分析；二：finally代碼塊終止定時任務(wù)。終止定時任務(wù)的這個沒什么說的，我們主要來看一下mainLoop()這個方法。

private void mainLoop() { 
  while (true) { // 開始死循環(huán) 
    try { 
      TimerTask task; 
      boolean taskFired; 
      synchronized(queue) { 
        // 如果任務(wù)隊列中為空并且定時任務(wù)沒有被取消話，線程被掛起 等待執(zhí)行任務(wù)的到來 
        while (queue.isEmpty() && newTasksMayBeScheduled) 
          queue.wait(); 
        if (queue.isEmpty()) 
          break; // 如果任務(wù)隊列中沒有任務(wù)了，則結(jié)束循環(huán)結(jié)束任務(wù) 
 
        // 如果隊列中有執(zhí)行任務(wù)的話，接著往下走 
        long currentTime, executionTime; 
        task = queue.getMin(); 
        synchronized(task.lock) { 
          if (task.state == TimerTask.CANCELLED) { 
            queue.removeMin(); 
            continue; // 如果執(zhí)行任務(wù)被取消的話 則移除當(dāng)前任務(wù)。這里會重新排隊列里的任務(wù)執(zhí)行順序 
          } 
          currentTime = System.currentTimeMillis(); 
          executionTime = task.nextExecutionTime; 
          if (taskFired = (executionTime<=currentTime)) { 
            if (task.period == 0) { // 如果只執(zhí)行一次的話，則在執(zhí)行完之后，結(jié)束執(zhí)行任務(wù) 
              queue.removeMin(); 
              task.state = TimerTask.EXECUTED; 
            } else { // 如果是固定頻率執(zhí)行任務(wù)的話，則計算下次執(zhí)行的時間 
              queue.rescheduleMin( 
               task.period<0 ? currentTime  - task.period 
                      : executionTime + task.period); 
            } 
          } 
        } 
        if (!taskFired) // 不到任務(wù)執(zhí)行的時候 等待線程調(diào)用 
          queue.wait(executionTime - currentTime); 
      } 
      if (taskFired) // 任務(wù)執(zhí)行時間到，調(diào)用任務(wù)的run方法，執(zhí)行任務(wù) 
        task.run(); 
    } catch(InterruptedException e) { 
    } 
  } 
}

這個類比較長，具體的執(zhí)行操作我在注釋里都標(biāo)注了。這個類基本上干了這樣幾件事：循環(huán)調(diào)用任務(wù)隊列中的任務(wù)，執(zhí)行隊列中的任務(wù)。執(zhí)行任務(wù)是什么時候放到執(zhí)行隊列中的呢?在schedule方法。我們來看看schedule的實現(xiàn)：

public void schedule(TimerTask task, long delay, long period) { 
  if (delay < 0) // 如果第一次執(zhí)行的時間小于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.這個間隔時間到死基本上也執(zhí)行不到 
  if (Math.abs(period) > (Long.MAX_VALUE >> 1)) 
    period >>= 1; 
 
  synchronized(queue) { 
    if (!thread.newTasksMayBeScheduled) //在任務(wù)的執(zhí)行方法中 如果定時任務(wù)已經(jīng)被取消的話 則拋出異常 
      throw new IllegalStateException("Timer already cancelled."); 
 
    synchronized(task.lock) { //object對象鎖 
      if (task.state != TimerTask.VIRGIN) // 剛開是執(zhí)行任務(wù)的時候 任務(wù)的狀態(tài)應(yīng)該是0的 
        throw new IllegalStateException( 
          "Task already scheduled or cancelled"); 
      task.nextExecutionTime = time; //下次執(zhí)行時間 在上面的mainLoop方法中有用到 
      task.period = period; //設(shè)置任務(wù)的間隔時間，在上面的mainLoop方法中有用到 
      task.state = TimerTask.SCHEDULED; // 調(diào)度方法被調(diào)用 設(shè)置定時任務(wù)的狀態(tài)為 已調(diào)度未執(zhí)行 
    } 
 
    queue.add(task); //把執(zhí)行任務(wù)加入到任務(wù)隊列中 
    if (queue.getMin() == task) 
      queue.notify(); // 如果任務(wù)隊列中的第一個任務(wù)為當(dāng)前任務(wù)的話，則把當(dāng)前任務(wù)放入到等鎖池中 等待執(zhí)行 
  } 
}

shedule這個方法做的事情比較簡單。最主要的作用是把TimerTask放到任務(wù)隊列中。

下面我們大致看一下TaskQueue的代碼：

  class TaskQueue { 
  //定義一個TimerTask的堆數(shù)組 <span style="white-space:pre">  </span> 
  private TimerTask[] queue = new TimerTask[128]; 
 
  //任務(wù)隊列中的任務(wù)數(shù)<span style="white-space:pre"> </span> 
  private int size = 0; 
 
 
  int size() { 
    return size; 
  } 
 
  //添加任務(wù)到優(yōu)先隊列中 如果數(shù)組的長度不夠的話會擴展數(shù)組 
  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); 
  } 
 
  //獲取優(yōu)先執(zhí)行的任務(wù) 
  TimerTask getMin() { 
    return queue[1]; 
  } 
 
   
  TimerTask get(int i) { 
    return queue[i]; 
  } 
  //移除掉排在第一位的不能執(zhí)行的任務(wù) 
  void removeMin() { 
    queue[1] = queue[size]; 
    queue[size--] = null; // Drop extra reference to prevent memory leak 把對象置空 等待gc回收 
    fixDown(1); 
  } 
 
  //刪除任務(wù)隊列隊列中的任務(wù) 這里用來一個斷言 來判斷 i 不能大于 size 
  void quickRemove(int i) { 
    assert i <= size; 
 
    queue[i] = queue[size]; 
    queue[size--] = null; // Drop extra ref to prevent memory leak 
  } 
 
  //重新設(shè)置優(yōu)先執(zhí)行任務(wù)的執(zhí)行時間 并對任務(wù)隊列進行重新排序 以確保最優(yōu)先的任務(wù) 優(yōu)先被執(zhí)行 
  void rescheduleMin(long newTime) { 
    queue[1].nextExecutionTime = newTime; 
    fixDown(1); 
  } 
 
 
  boolean isEmpty() { 
    return size==0; 
  } 
 
  //清空任務(wù)隊列 定時任務(wù)結(jié)束  
  void clear() { 
    // Null out task references to prevent memory leak 
    for (int i=1; i<=size; i++) 
      queue[i] = null; 
 
    size = 0; 
  } 
 
  //兩個堆排序 選出最優(yōu)先的執(zhí)行任務(wù) 
  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，到這里定時任務(wù)的源碼大致分析完畢。

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: