欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java实现多线程之定时器任务

程序员文章站 2024-03-06 09:13:49
在java中timer是java.util包中的一个工具类,提供了定时器的功能。我们可以创建一个timer对象,然后调用其schedule方法在某个特定的时间去执行一个特定...

在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 style="white-space:pre">  </span> 
  private timertask[] queue = new timertask[128]; 
 
  //任务队列中的任务数<span style="white-space:pre"> </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,到这里定时任务的源码大致分析完毕。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。