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 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,到这里定时任务的源码大致分析完毕。

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

时间: 2017-02-18

Java多线程下载文件实例详解

本文实例为大家分享了Java多线程下载文件的具体代码,供大家参考,具体内容如下 import java.io.File; import java.io.InputStream; import java.io.RandomAccessFile; import java.net.HttpURLConnection; import java.net.URL; public class MulThreadDownload { public static void main(String[] args)

Java编程之多线程死锁与线程间通信简单实现代码

死锁定义 死锁是指两个或者多个线程被永久阻塞的一种局面,产生的前提是要有两个或两个以上的线程,并且来操作两个或者多个以上的共同资源:我的理解是用两个线程来举例,现有线程A和B同时操作两个共同资源a和b,A操作a的时候上锁LockA,继续执行的时候,A还需要LockB进行下面的操作,这个时候b资源在被B线程操作,刚好被上了锁LockB,假如此时线程B刚好释放了LockB则没有问题,但没有释放LockB锁的时候,线程A和B形成了对LockB锁资源的争夺,从而造成阻塞,形成死锁:具体其死锁代码如下:

简单谈谈RxJava和多线程并发

前言 相信对于RxJava,大家应该都很熟悉,他最核心的两个字就是异步,诚然,它对异步的处理非常的出色,但是异步绝对不等于并发,更不等于线程安全,如果把这几个概念搞混了,错误的使用RxJava,是会来带非常多的问题的. RxJava与并发 首先让我们来看一段RxJava协议的原文: Observables must issue notifications to observers serially (not in parallel). They may issue these notificat

Java实现多线程文件下载的代码示例

Java实现多线程文件下载思路: 1.基本思路是将文件分段切割.分段传输.分段保存. 2.分段切割用到HttpUrlConnection对象的setRequestProperty("Range", "bytes=" + start + "-" + end)方法. 3.分段传输用到HttpUrlConnection对象的getInputStream()方法. 4.分段保存用到RandomAccessFile的seek(int start)方法. 5

Java 多线程有序执行的几种方法总结

Java 多线程有序执行的几种方法总结 同事无意间提出了这个问题,亲自实践了两种方法.当然肯定还会有更多更好的方法. 方法一 import java.util.concurrent.atomic.AtomicInteger; public class OrderedThread1 { static AtomicInteger count = new AtomicInteger(0); public static void main(String[] args) throws Interrupte

java检查服务器的连通两种方法代码分享

首先要了解一下ping的内容. 概述 PING (Packet Internet Groper),因特网包探索器,用于测试网络连接量的程序.Ping发送一个ICMP(Internet Control Messages Protocol)即因特网信报控制协议:回声请求消息给目的地并报告是否收到所希望的ICMPecho (ICMP回声应答).它是用来检查网络是否通畅或者网络连接速度的命令.作为一个生活在网络上的管理员或者黑客来说,ping命令是第一个必须掌握的DOS命令,它所利用的原理是这样的:利用

Java多线程中线程的两种创建方式及比较代码示例

1.线程的概念:线程(thread)是指一个任务从头至尾的执行流,线程提供一个运行任务的机制,对于java而言,一个程序中可以并发的执行多个线程,这些线程可以在多处理器系统上同时运行.当程序作为一个应用程序运行时,java解释器为main()方法启动一个线程. 2.并行与并发: (1)并发:在单处理器系统中,多个线程共享CPU时间,而操作系统负责调度及分配资源给它们. (2)并行:在多处理器系统中,多个处理器可以同时运行多个线程,这些线程在同一时间可以同时运行,而不同于并发,只能多个线程共享CP

java多线程之线程同步七种方式代码示例

为何要使用同步?  java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),     将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程的调用,     从而保证了该变量的唯一性和准确性. 1.同步方法  即有synchronized关键字修饰的方法.     由于java的每个对象都有一个内置锁,当用此关键字修饰方法时,     内置锁会保护整个方法.在调用该方法前,需要获得内置锁,否则就处于阻塞状态.     代码

Java多线程atomic包介绍及使用方法

引言 Java从JDK1.5开始提供了java.util.concurrent.atomic包,方便程序员在多线程环境下,无锁的进行原子操作.原子变量的底层使用了处理器提供的原子指令,但是不同的CPU架构可能提供的原子指令不一样,也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞. Atomic包介绍 在Atomic包里一共有12个类,四种原子更新方式,分别是原子更新基本类型,原子更新数组,原子更新引用和原子更新字段.Atomic包里的类基本都是使用Unsafe实现的包装类. 原子

Java创建子线程的两种方法

摘要: 其实两种方法归结起来看还是一种,都是利用Thread的构造器进行创建,区别就是一种是无参的,一种是有参的. 一.继承Thread线程类: 通过继承Thread类,重写run方法,子类对象就可以调用start方法启动线程,JVM就会调用此线程的run方法. 代码如下: public class MyThread extends Thread { public MyThread() { super(); } @Override public void run() { } // 线程执行结束

Java中求最大值的4种方法实例代码

前言 本文主要给大家分享了关于java求最大值的4中方法,文中给出了完整的示例代码,下面话不多少了,来一起看看吧 示例代码: /** *@author Prannt *求最大值(或最小值) *本例以int数据类型为例,可指定其他数据类型 */ //方法一:直接法,求最小值类似 public class Deno05ArrayMax { public static void main(String[] args) { //数据类型可指定 int [] array = {5,15,20,30,100

Java从控制台读入数据的几种方法总结

这里记录Java中从控制台读入信息的几种方式,已备后查! (1)JDK 1.4(JDK 1.5和JDK 1.6也都兼容这种方法) public class TestConsole1 { public static void main(String[] args) { String str = readDataFromConsole("Please input string:); System.out.println("The information from console: + st

Java追加文件内容的三种方法实例代码

整理文档,搜刮出一个Java追加文件内容的三种方法的代码,稍微整理精简一下做下分享. import Java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.RandomAccessFile;

网页中JS函数自动执行常用三种方法

本文为大家分享了在网页中JS函数自动执行常用方法,供大家参考,具体内容如下 一.JS方法 1.最简单的调用方式,直接写到html的body标签里面: <body onload="myfunction()"> <html> <body onload="func1();func2();func3();"> </body> </html> 2.在JS语句调用: <script type="text