Timer 的队列分析

最新推荐文章于 2022-10-13 16:58:28 发布
最新推荐文章于 2022-10-13 16:58:28 发布
阅读量523 收藏
点赞数 1
分类专栏： java基础
本文章转自 :http://blog.csdn.net/nileader4dev/archive/2010/12/10/6067547.aspx

Timer中最主要由三个部分组成: 任务 TimerTask 、  任务队列: TaskQueue queue 和 任务调试者:TimerThread thread

他们之间的关系可以通过下面图示:




在这个图中,可以清楚地看到这Timer本身及其和这三个部分的关系:

1. Timer可以看作是面向开发人员的一个”接口”

2. 所有向Timer添加的任务都会被放入一个TaskQueue类型的任务队列中去.(如何安排任务优先级顺序下文会讲)

3. 任务调度由TimerThread负责

任务单元 TimerTask

首先看一下任务单元实体类: TimerTask.

在这个类中, 要关注的是任务状态和几个状态常量:

Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     /** 标识任务的状态 */    
  4.     int state = VIRGIN;    
  5.     /** 任务的状态的常量 */    
  6.     static final int VIRGIN = 0;    
  7.     static final int SCHEDULED   = 1;    
  8.     static final int EXECUTED    = 2;    
  9.     static final int CANCELLED   = 3;    
view plaincopy to clipboardprint?

    /** 标识任务的状态 */  
    int state = VIRGIN;  
    /** 任务的状态的常量 */  
    static final int VIRGIN = 0;  
    static final int SCHEDULED   = 1;  
    static final int EXECUTED    = 2;  
    static final int CANCELLED   = 3;


以及一个比较重要的两个成员变量:

Java代码   收藏代码
  1. long nextExecutionTime;    
  2. long period = 0;    
    long nextExecutionTime;  
    long period = 0;


nextExecutionTime 这个成员变量用到记录该任务下次执行时间, 其格式和System.currentTimeMillis()一致.

这个值是作为任务队列中任务排序的依据. 任务调试者执行每个任务前会对这个值作处理,重新计算下一次任务执行时间,并为这个变量赋值.

period 用来描述任务的执行方式: 0表示不重复执行的任务. 正数表示固定速率执行的任务. 负数表示固定延迟执行的任务.

(固定速率: 不考虑该任务上一次执行情况,始终从开始时间算起的每period执行下一次.   固定延迟: 考虑该任务一次执行情况,在上一次执行后period执行下一次).

任务队列 TaskQueue   

    事实上任务队列是一个数组, 采用平衡二叉堆来实现他的优先级调度, 并且是一个小顶堆. 需要注意的是, 这个堆中queue[n] 的孩子是queue[2*n] 和 queue[2*n+1].

    任务队列的优先级按照TimerTask类的成员变量nextExecutionTime值来排序(注意, 这里的任务指的是那些交由定时器来执行的, 继承TimerTask的对象).
    在任务队列中, nextExecutionTime最小就是所有任务中最早要被调度来执行的, 所以被安排在queue[1] (假设任务队列非空).
    对于堆中任意一个节点n, 和他的任意子孙节点d,一定遵循: n.nextExecutionTime <= d.nextExecutionTime.

[添加任务]
Java代码   收藏代码
  1. void add(TimerTask task) {    
  2.       if (size + 1 == queue.length)    
  3.       queue = Arrays.copyOf(queue, 2 * queue.length);    
  4.       queue[++size] = task;     
  5.       fixUp(size);    
  6. }    
    void add(TimerTask task) {  
          if (size + 1 == queue.length)  
          queue = Arrays.copyOf(queue, 2 * queue.length);  
          queue[++size] = task;   
          fixUp(size);  
    }


首先会判断是否已经满了,(任务队列的初始容量是128 ),如果已经满了, 那么容量扩大至原来2倍, 然后将需要添加的任务放到队列最后.

之后就会调用fixUp 方法来进行队列中任务优先级调整. fixUp方法的作用是尽量将队列中指定位置(k)的任务向队列前面移动, 即提高它的优先级. 因为新加入的方法很有可能比已经在任务队列中的其它任务要更早执行.

Java代码   收藏代码
  1. private void fixUp(int k) {    
  2.     while (k > 1) {    
  3.         int j = k >> 1; // 对于正数,右移位 <==> j = k/2, 所以j的位置就是k的父亲节点    
  4.         if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)    
  5.             break;    
  6.         TimerTask tmp = queue[j];    
  7.         queue[j] = queue[k];    
  8.         queue[k] = tmp;    
  9.         k = j;    
  10.     }    
  11. }    
    private void fixUp(int k) {  
        while (k > 1) {  
            int j = k >> 1; // 对于正数,右移位 <==> j = k/2, 所以j的位置就是k的父亲节点  
            if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)  
                break;  
            TimerTask tmp = queue[j];  
            queue[j] = queue[k];  
            queue[k] = tmp;  
            k = j;  
        }  
    }


这个过程可以这个描述: 不断地将k位置上元素和它的父亲进行比较, 上文也提到过了. 由于必须满足 “对于堆中任意一个节点n, 和他的任意子孙节点d,一定遵循: n.nextExecutionTime <= d.nextExecutionTime.”, 那么在不断比较过程中, 如果发现孩子节点比父亲小的时候, 那么将父亲和孩子位置互换. 直到来到队列第一个位置.




Java代码   收藏代码
  1. void removeMin() {    
  2.     queue[1] = queue[size];    
  3.     queue[size–] = null; // Drop extra reference to prevent memory leak    
  4.     fixDown(1);    
  5. }    
    void removeMin() {  
        queue[1] = queue[size];  
        queue[size--] = null; // Drop extra reference to prevent memory leak  
        fixDown(1);  
    }


从任务队列中移除一个任务的过程, 首先直接将当前任务队列中最后一个任务赋给queue[1], 然后将队列中任务数量–, 最后和上面类似, 但是这里是调用fixDown(int k)方法了, 尽量将k位置的任务向队列后面移动.

Java代码   收藏代码
  1. /**  
  2.  * -将k位置的元素向堆底方向移动.<br>  
  3.  * 1. j = k << 1, 将j定位到儿子中.<br>  
  4.  * 2. 将 j 精确定位到较小的儿子.<br>  
  5.  * 3. 然后k与j比较,如果k大于j的话, 那么互换<br>  
  6.  * 4.继续…  
  7.  */    
  8. private void fixDown(int k) {    
  9.     int j;    
  10.     // 如果还没有到队列的最后,并且没有溢出( j > 0 )    
  11.     // 在没有出现溢出的情况下, j = k << 1 等价于 j = 2 * k ;    
  12.     while ((j = k << 1) <= size && j > 0) {    
  13.         // 找到k的两个孩子中小的那个.    
  14.         if (j < size && queue[j].nextExecutionTime > queue[j + 1].nextExecutionTime)    
  15.             j++; // j indexes smallest kid    
  16.         // 找到这个较小的孩子后,(此时k是父亲,j是较小的儿子),父亲和儿子互换位置,即k和j换位子.这样一直下去就可以将这个较大的queue[1]向下堆底移动了.    
  17.         if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)    
  18.             break;    
  19.         TimerTask tmp = queue[j];    
  20.         queue[j] = queue[k];    
  21.         queue[k] = tmp;    
  22.         k = j;    
  23.     }    
  24. }   
/** 
 * -将k位置的元素向堆底方向移动.<br> 
 * 1. j = k << 1, 将j定位到儿子中.<br> 
 * 2. 将 j 精确定位到较小的儿子.<br> 
 * 3. 然后k与j比较,如果k大于j的话, 那么互换<br> 
 * 4.继续... 
 */  
private void fixDown(int k) {  
    int j;  
    // 如果还没有到队列的最后,并且没有溢出( j > 0 )  
    // 在没有出现溢出的情况下, j = k << 1 等价于 j = 2 * k ;  
    while ((j = k << 1) <= size && j > 0) {  
        // 找到k的两个孩子中小的那个.  
        if (j < size && queue[j].nextExecutionTime > queue[j + 1].nextExecutionTime)  
            j++; // j indexes smallest kid  
        // 找到这个较小的孩子后,(此时k是父亲,j是较小的儿子),父亲和儿子互换位置,即k和j换位子.这样一直下去就可以将这个较大的queue[1]向下堆底移动了.  
        if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)  
            break;  
        TimerTask tmp = queue[j];  
        queue[j] = queue[k];  
        queue[k] = tmp;  
        k = j;  
    }  
}


下面来看看任务调度者是如何工作的.

任务调度 TimerThread

关于任务调度主要要讲下一个成员变量 newTasksMayBeScheduled 和 调度方法 mainLoop().

Java代码   收藏代码
  1. boolean newTasksMayBeScheduled = true;    
  2.   
  3.  plaincopy to clipboardprint?  
  4.   
  5. private void mainLoop() {    
  6.         while (true) {    
  7.             try {    
  8.                 TimerTask task;    
  9.                 boolean taskFired = false;    
  10.                 synchronized (queue) {    
  11.                     while (queue.isEmpty() && newTasksMayBeScheduled) {    
  12.                         queue.wait();    
  13.                     }    
  14.                     if (queue.isEmpty())    
  15.                         break; // 直接挑出mainLoop了.    
  16.                     long currentTime, executionTime;    
  17.                     task = queue.getMin(); // 获取这个任务队列第一个任务    
  18.                     synchronized (task.lock) {    
  19.                         if (task.state == TimerTask.CANCELLED) {    
  20.                             queue.removeMin();    
  21.                             continue;    
  22.                         }    
  23.                         currentTime = System.currentTimeMillis();    
  24.                         executionTime = task.nextExecutionTime;    
  25.                         if (taskFired = (executionTime <= currentTime)) {    
  26.                             if (task.period == 0) { // Non-repeating, remove    
  27.                                 queue.removeMin();    
  28.                                 task.state = TimerTask.EXECUTED;    
  29.                             } else { // Repeating task, reschedule    
  30.                                 queue.rescheduleMin(task.period < 0 ? currentTime - task.period : executionTime    
  31.                                         + task.period);    
  32.                             }    
  33.                         }    
  34.                     }//释放锁    
  35.                     if (!taskFired)    
  36.                         queue.wait(executionTime - currentTime);    
  37.                 }    
  38.                 if (taskFired) // Task fired; run it, holding no locks    
  39.                     task.run();    
  40.             } catch (InterruptedException e) {    
  41.             }    
  42.         }// while(true)    
  43.     }    
    boolean newTasksMayBeScheduled = true;  

view plaincopy to clipboardprint?

    private void mainLoop() {  
            while (true) {  
                try {  
                    TimerTask task;  
                    boolean taskFired = false;  
                    synchronized (queue) {  
                        while (queue.isEmpty() && newTasksMayBeScheduled) {  
                            queue.wait();  
                        }  
                        if (queue.isEmpty())  
                            break; // 直接挑出mainLoop了.  
                        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) { // Non-repeating, remove  
                                    queue.removeMin();  
                                    task.state = TimerTask.EXECUTED;  
                                } else { // Repeating task, reschedule  
                                    queue.rescheduleMin(task.period < 0 ? currentTime - task.period : executionTime  
                                            + task.period);  
                                }  
                            }  
                        }//释放锁  
                        if (!taskFired)  
                            queue.wait(executionTime - currentTime);  
                    }  
                    if (taskFired) // Task fired; run it, holding no locks  
                        task.run();  
                } catch (InterruptedException e) {  
                }  
            }// while(true)  
        }




原创  JDK自带的java.util.Timer定时器的实现原理 收藏

本文主要介绍JKD自带的java.util.Timer定时器的实现原理.

如果你仅仅只是想知道如何在自己的程序中来使用java.util.Timer的一些方法,那么请移步:                                                                    http://blog.csdn.net/Twent/archive/2005/09/20/485528.aspx .                         

API介绍在这里: http://online.chinaitpower.com/api/jdk150/java/util/Timer.html

Timer中最主要由三个部分组成: 任务 TimerTask 、  任务队列: TaskQueue queue 和 任务调试者:TimerThread thread

他们之间的关系可以通过下面图示:

在这个图中,可以清楚地看到这Timer本身及其和这三个部分的关系:

1. Timer可以看作是面向开发人员的一个”接口”

2. 所有向Timer添加的任务都会被放入一个TaskQueue类型的任务队列中去.(如何安排任务优先级顺序下文会讲)

3. 任务调度由TimerThread负责

任务单元 TimerTask

首先看一下任务单元实体类: TimerTask.

在这个类中, 要关注的是任务状态和几个状态常量:

Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     /** 标识任务的状态 */    
  4.     int state = VIRGIN;    
  5.     /** 任务的状态的常量 */    
  6.     static final int VIRGIN = 0;    
  7.     static final int SCHEDULED   = 1;    
  8.     static final int EXECUTED    = 2;    
  9.     static final int CANCELLED   = 3;    
view plaincopy to clipboardprint?

    /** 标识任务的状态 */  
    int state = VIRGIN;  
    /** 任务的状态的常量 */  
    static final int VIRGIN = 0;  
    static final int SCHEDULED   = 1;  
    static final int EXECUTED    = 2;  
    static final int CANCELLED   = 3;


以及一个比较重要的两个成员变量:

Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     long nextExecutionTime;    
  4.     long period = 0;    
view plaincopy to clipboardprint?

    long nextExecutionTime;  
    long period = 0;


nextExecutionTime 这个成员变量用到记录该任务下次执行时间, 其格式和System.currentTimeMillis()一致.

这个值是作为任务队列中任务排序的依据. 任务调试者执行每个任务前会对这个值作处理,重新计算下一次任务执行时间,并为这个变量赋值.

period 用来描述任务的执行方式: 0表示不重复执行的任务. 正数表示固定速率执行的任务. 负数表示固定延迟执行的任务.

(固定速率: 不考虑该任务上一次执行情况,始终从开始时间算起的每period执行下一次.   固定延迟: 考虑该任务一次执行情况,在上一次执行后period执行下一次).

任务队列 TaskQueue   

    事实上任务队列是一个数组, 采用平衡二叉堆来实现他的优先级调度, 并且是一个小顶堆. 需要注意的是, 这个堆中queue[n] 的孩子是queue[2*n] 和 queue[2*n+1].

    任务队列的优先级按照TimerTask类的成员变量nextExecutionTime值来排序(注意, 这里的任务指的是那些交由定时器来执行的, 继承TimerTask的对象).
    在任务队列中, nextExecutionTime最小就是所有任务中最早要被调度来执行的, 所以被安排在queue[1] (假设任务队列非空).
    对于堆中任意一个节点n, 和他的任意子孙节点d,一定遵循: n.nextExecutionTime <= d.nextExecutionTime.

[添加任务]

  
Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     void add(TimerTask task) {    
  4.           if (size + 1 == queue.length)    
  5.           queue = Arrays.copyOf(queue, 2 * queue.length);    
  6.           queue[++size] = task;     
  7.           fixUp(size);    
  8.     }    
view plaincopy to clipboardprint?

    void add(TimerTask task) {  
          if (size + 1 == queue.length)  
          queue = Arrays.copyOf(queue, 2 * queue.length);  
          queue[++size] = task;   
          fixUp(size);  
    }


首先会判断是否已经满了,(任务队列的初始容量是128 ),如果已经满了, 那么容量扩大至原来2倍, 然后将需要添加的任务放到队列最后.

之后就会调用fixUp 方法来进行队列中任务优先级调整. fixUp方法的作用是尽量将队列中指定位置(k)的任务向队列前面移动, 即提高它的优先级. 因为新加入的方法很有可能比已经在任务队列中的其它任务要更早执行.

Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     private void fixUp(int k) {    
  4.         while (k > 1) {    
  5.             int j = k >> 1; // 对于正数,右移位 <==> j = k/2, 所以j的位置就是k的父亲节点    
  6.             if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)    
  7.                 break;    
  8.             TimerTask tmp = queue[j];    
  9.             queue[j] = queue[k];    
  10.             queue[k] = tmp;    
  11.             k = j;    
  12.         }    
  13.     }   
view plaincopy to clipboardprint?

    private void fixUp(int k) {  
        while (k > 1) {  
            int j = k >> 1; // 对于正数,右移位 <==> j = k/2, 所以j的位置就是k的父亲节点  
            if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)  
                break;  
            TimerTask tmp = queue[j];  
            queue[j] = queue[k];  
            queue[k] = tmp;  
            k = j;  
        }  
    }


这个过程可以这个描述: 不断地将k位置上元素和它的父亲进行比较, 上文也提到过了. 由于必须满足 “对于堆中任意一个节点n, 和他的任意子孙节点d,一定遵循: n.nextExecutionTime <= d.nextExecutionTime.”, 那么在不断比较过程中, 如果发现孩子节点比父亲小的时候, 那么将父亲和孩子位置互换. 直到来到队列第一个位置.

fixUp(int newTask)过程

[移除任务]

Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     void removeMin() {    
  4.         queue[1] = queue[size];    
  5.         queue[size–] = null; // Drop extra reference to prevent memory leak    
  6.         fixDown(1);    
  7.     }   
view plaincopy to clipboardprint?

    void removeMin() {  
        queue[1] = queue[size];  
        queue[size--] = null; // Drop extra reference to prevent memory leak  
        fixDown(1);  
    }


从任务队列中移除一个任务的过程, 首先直接将当前任务队列中最后一个任务赋给queue[1], 然后将队列中任务数量–, 最后和上面类似, 但是这里是调用fixDown(int k)方法了, 尽量将k位置的任务向队列后面移动.

Java代码   收藏代码
  1. view plaincopy to clipboardprint?  
  2.   
  3.     /**  
  4.      * -将k位置的元素向堆底方向移动.<br>  
  5.      * 1. j = k << 1, 将j定位到儿子中.<br>  
  6.      * 2. 将 j 精确定位到较小的儿子.<br>  
  7.      * 3. 然后k与j比较,如果k大于j的话, 那么互换<br>  
  8.      * 4.继续…  
  9.      */    
  10.      private void fixDown(int k) {    
  11.         int j;    
  12.         // 如果还没有到队列的最后,并且没有溢出( j > 0 )    
  13.         // 在没有出现溢出的情况下, j = k << 1 等价于 j = 2 * k ;    
  14.         while ((j = k << 1) <= size && j > 0) {    
  15.             // 找到k的两个孩子中小的那个.    
  16.             if (j < size && queue[j].nextExecutionTime > queue[j + 1].nextExecutionTime)    
  17.                 j++; // j indexes smallest kid    
  18.             // 找到这个较小的孩子后,(此时k是父亲,j是较小的儿子),父亲和儿子互换位置,即k和j换位子.这样一直下去就可以将这个较大的queue[1]向下堆底移动了.    
  19.             if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)    
  20.                 break;    
  21.             TimerTask tmp = queue[j];    
  22.             queue[j] = queue[k];    
  23.             queue[k] = tmp;    
  24.             k = j;    
  25.         }    
  26.     }   
view plaincopy to clipboardprint?

    /** 
     * -将k位置的元素向堆底方向移动.<br> 
     * 1. j = k << 1, 将j定位到儿子中.<br> 
     * 2. 将 j 精确定位到较小的儿子.<br> 
     * 3. 然后k与j比较,如果k大于j的话, 那么互换<br> 
     * 4.继续... 
     */  
     private void fixDown(int k) {  
        int j;  
        // 如果还没有到队列的最后,并且没有溢出( j > 0 )  
        // 在没有出现溢出的情况下, j = k << 1 等价于 j = 2 * k ;  
        while ((j = k << 1) <= size && j > 0) {  
            // 找到k的两个孩子中小的那个.  
            if (j < size && queue[j].nextExecutionTime > queue[j + 1].nextExecutionTime)  
                j++; // j indexes smallest kid  
            // 找到这个较小的孩子后,(此时k是父亲,j是较小的儿子),父亲和儿子互换位置,即k和j换位子.这样一直下去就可以将这个较大的queue[1]向下堆底移动了.  
            if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)  
                break;  
            TimerTask tmp = queue[j];  
            queue[j] = queue[k];  
            queue[k] = tmp;  
            k = j;  
        }  
    }


下面来看看任务调度者是如何工作的.

任务调度 TimerThread

关于任务调度主要要讲下一个成员变量 newTasksMayBeScheduled 和 调度方法 mainLoop().

Java代码   收藏代码
  1. boolean newTasksMayBeScheduled = true;    
    boolean newTasksMayBeScheduled = true;

Java代码   收藏代码
  1. private void mainLoop() {    
  2.         while (true) {    
  3.             try {    
  4.                 TimerTask task;    
  5.                 boolean taskFired = false;    
  6.                 synchronized (queue) {    
  7.                     while (queue.isEmpty() && newTasksMayBeScheduled) {    
  8.                         queue.wait();    
  9.                     }    
  10.                     if (queue.isEmpty())    
  11.                         break; // 直接挑出mainLoop了.    
  12.                     long currentTime, executionTime;    
  13.                     task = queue.getMin(); // 获取这个任务队列第一个任务    
  14.                     synchronized (task.lock) {    
  15.                         if (task.state == TimerTask.CANCELLED) {    
  16.                             queue.removeMin();    
  17.                             continue;    
  18.                         }    
  19.                         currentTime = System.currentTimeMillis();    
  20.                         executionTime = task.nextExecutionTime;    
  21.                         if (taskFired = (executionTime <= currentTime)) {    
  22.                             if (task.period == 0) { // Non-repeating, remove    
  23.                                 queue.removeMin();    
  24.                                 task.state = TimerTask.EXECUTED;    
  25.                             } else { // Repeating task, reschedule    
  26.                                 queue.rescheduleMin(task.period < 0 ? currentTime - task.period : executionTime    
  27.                                         + task.period);    
  28.                             }    
  29.                         }    
  30.                     }//释放锁    
  31.                     if (!taskFired)    
  32.                         queue.wait(executionTime - currentTime);    
  33.                 }    
  34.                 if (taskFired) // Task fired; run it, holding no locks    
  35.                     task.run();    
  36.             } catch (InterruptedException e) {    
  37.             }    
  38.         }// while(true)    
  39.     }    
    private void mainLoop() {  
            while (true) {  
                try {  
                    TimerTask task;  
                    boolean taskFired = false;  
                    synchronized (queue) {  
                        while (queue.isEmpty() && newTasksMayBeScheduled) {  
                            queue.wait();  
                        }  
                        if (queue.isEmpty())  
                            break; // 直接挑出mainLoop了.  
                        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) { // Non-repeating, remove  
                                    queue.removeMin();  
                                    task.state = TimerTask.EXECUTED;  
                                } else { // Repeating task, reschedule  
                                    queue.rescheduleMin(task.period < 0 ? currentTime - task.period : executionTime  
                                            + task.period);  
                                }  
                            }  
                        }//释放锁  
                        if (!taskFired)  
                            queue.wait(executionTime - currentTime);  
                    }  
                    if (taskFired) // Task fired; run it, holding no locks  
                        task.run();  
                } catch (InterruptedException e) {  
                }  
            }// while(true)  
        }


newTasksMayBeScheduled变量用来表示是否需要继续等待新任务了.

默认情况这个变量是true , 并且这个变量一直是true的,只有两种情况的时候会变成 false
  1.当调用Timer的cancel方法
  2.没有引用指向Timer对象了.

任务调度: mainLoop()方法中的一个while可以理解为一次任务调度:

STEP 1 :  判断任务队列中是否还有任务, 如果任务队列为空了, 但是newTasksMayBeScheduled变量还是true, 表明需要继续等待新任务, 所以一直等待.

STEP 2 : 等待唤醒后, 再次判断队列中是否有任务. 如果还是没有任务,那么直接结束定时器工作了.

              因为queue只在两个地方被调用: addTask和cancel
            1.向任务队列中增加任务会唤醒

            2.timer.cancel()的时候也会唤醒
     那么这里如果还是empty,那么就是cancel的唤醒了,所以可以结束timer工作了.

STEP 3 : 从任务队列中取出第一个任务,即nextExecutionTime最小的那个任务.

STEP 4: 判断这个任务是否已经被取消. 如果已经被取消了,那么就直接从任务队列中移除这个任务(removeMin() ),然后直接进入下一个任务调度周期.

STEP 5 : 判断是否到了或者已经超过了这个任务应该执行的时间了.

      如果到了 , 不会立即执行它,而是会在这次循环的最后来执行它.
      这里做的事情可以看作是为下一个调度周期进行准备:包括:
       1. 判断是否是重复(repeating)任务,如果 task.period == 0, 那么就不是重复任务,所以可以直接将这个任务从任务队列中移除了(removeMin() ),因为没有必要留到下一个调度周期中去了.
      2. 如果是需要重复执行的任务, 那么就要重新设置这个任务的nextExecutionTime,即调用方法queue.rescheduleMin(long) ,这个方法中会调用fixDown(1) 负责重新调整任务队列的优先级顺序.

      如果还没有到执行时间 ,  一直等到 queue.wait(executionTime - currentTime)

并且等待完毕后,似乎可以开始运行了, 但是这里设计成不立即运行,而是直接进入下一个任务调度周期.(因为taskFired =false,所以不会在这次进行执行的.)     

STEP: 6 开始调用任务的run方法运行任务.
安卓工匠
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Timer解析
weixin_49823868的博客
04-25 168
java中Timer源码解析
Timer和TimerTask
热门推荐
blueling51的专栏
11-03 1万+
有时候需要每隔一段时间去执行某个任务，在Java中提供了Timer和TimerTask来完成这个任务，这个两个类位于java.util包中。Timer类是Java中一种线程设施，用于安排以后在后台线程中执行的任务，可以安排任务执行一次或定期重复执行。与每个Timer对象对应的是单个后台线程，用于顺序的执行所有计时器任务。       对Timer对象最后的引用完成后，并且所有未处理的任务都已执行
Timer源码之TaskQueue
weixin_34238633的博客
06-14 108
2019独角兽企业重金招聘Python工程师标准>>> ...
java timer队列_Java Timer任务调度详解
weixin_34867001的博客
02-13 286
Timer对象最后的引用完成后，所有未处理的任务都已执行完成后，计时器的任务执行线程会正常终止(并且成为垃圾回收的对象)。这可能要很长时间后才发生。默认情况下，任务执行线程并不作为守护线程来运行，所以它能够阻止应用程序终止。如果调用者想要快速终止计时器的任务执行线程，那么调用者应该调用计时器的cancel 方法。代码案例：import java.util.Date;import java.util...
Java 定时器 Timer 源码分析和使用建议
weixin_33937913的博客
12-28 174
Timer 定时器相信都不会陌生，之所以拿它来做源码分析，是发现整个控制流程可以体现很多有意思的东西。 在业务开发中经常会遇到执行一些简单定时任务的需求，通常为了避免做一些看起来复杂的控制逻辑，一般考虑使用 Timer 来实现定时任务的执行，下面先给出一个最简单用法的例子： Timer timer = new Timer(); TimerTask timerTask = new TimerTa...
timer_timer_源码
10-02
在分析源代码时，我们需要关注定时器的初始化、添加任务、启动、停止、取消任务等核心方法，以及如何处理时间计算和时间间隔的精度问题。同时，理解其设计模式，如观察者模式（Observer Pattern），在定时器触发时...
C#中Forms.Timer、Timers.Timer、Threading.Timer的用法分析
09-04
然而，这也意味着如果在Tick事件处理程序中执行了长时间的UI操作，可能会阻塞消息队列，导致Tick事件丢失或UI无响应。此外，Windows.Forms.Timer的精度较低，约为55毫秒。 ```csharp public partial class Form1 : ...
GO语言写的延迟队列代码
05-19
通过分析`delay-queue-master`项目的源码，我们可以深入理解Go语言如何优雅地实现延迟队列，以及在实际应用中如何根据需求进行优化和扩展。例如，为了提高性能，可以考虑使用`btree`或`heap`数据结构来优化查找和...
python_epoll_timer.rar
09-30
在这个项目中，`timer_queue.py`很可能是实现了定时器队列的主逻辑。这个队列可能包含了一些定时任务，每个任务都有一个关联的时间戳，当时间戳到达时，任务就会被触发执行。它可能使用了epoll的`EPOLLIN`事件来监听...
前端项目-d3-timer.zip
09-02
【前端项目-d3-timer.zip】是一个专注于前端开发的项目，它主要利用D3.js库中的timer模块，为开发者提供了一种高效的方式来管理和...开发者可以通过分析和实践这个项目，提升自己在前端动画设计和数据可视化的技能。
从Timer中学习优先队列的实现
weixin_34235105的博客
04-30 193
从Timer中学习优先队列的实现 Timer是Java定时器的实现，用来调度定时执行的任务和执行一次的任务，就像JavaScript的setInterval和setTimeout的意思，它也可以作为后台程序（Daemon）运行。 Timer Timer调度的实现是通过TimerThread辅助类来实现的，在构造Timer实例的时候Time...
java timer并发_Java并发编程笔记之Timer源码分析
weixin_39890431的博客
02-26 168
timer在JDK里面，是很早的一个API了。具有延时的，并具有周期性的任务，在newScheduledThreadPool出来之前我们一般会用Timer和TimerTask来做，但是Timer存在一些缺陷，为什么这么说呢？Timer只创建唯一的线程来执行所有Timer任务。如果一个timer任务的执行很耗时，会导致其他TimerTask的时效准确性出问题。例如一个TimerTask每10秒执行一...
Timer源码分析
u013978512的博客
08-20 700
二、Timer的缺陷 1、由于执行任务的线程只有一个，所以如果某个任务的执行时间过长，那么将破坏其他任务的定时精确性。如一个任务每1秒执行一次，而另一个任务执行一次需要5秒，那么如果是固定速率的任务，那么会在5秒这个任务执行完成后连续执行5次，而固定延迟的任务将丢失4次执行。 2、如果执行某个任务过程中抛出了异常，那么执行线程将会终止，导致Timer中的其他任务也不能再执行。 3、Timer使用的是绝对时间，即是某个时间点，所以它执行依赖系统的时间，如果系统时间修改了的话，将导致任务可能不会被执行。
Timer详解
LiuRenyou的博客
07-03 5061
文章目录timer介绍：timer的使用：timer源码分析：生产者代码消费者代码timer的schedule和scheduleAtFixedRate区别：timer的缺点:timer的替代产品： timer介绍： Timer是Josh Bloch在jdk1.3发布的一个新的api，主要用于做定时任务. timer的使用： 1：schedule(TimerTask task, long delay...
timer定时器的简单用法
zion--6135的博客
10-13 273
定时每 sec去执行一次callback函数。
TimerQueue类详解
阳光梦的专栏
05-14 2846
TimerQueue.h #ifndef MUDUO_NET_TIMERQUEUE_H #define MUDUO_NET_TIMERQUEUE_H #include #include #include #include #include #include #include namespace muduo { namespace
linux驱动之定时任务timer，队列queue，小任务tasklet机制及用法
感觉身体被掏空
08-27 4325
1：内核定时器： 在内核中有系统自带的定时器，达到一定的时间就可以进行一个操作，这个和单片机中的定时器中断一样。 包含头文件是 Timer.h (\include\linux)结构体是timer_list struct timer_list{ /* * All fields that change during normal runtime grouped to the * sa
基于ACE的定时器队列实现
白云哥
11-01 4338
    定时器MMO中的作用不需要做过多的强调，对于大多数的游戏项目来说，都是按照linux内核定时器的原理自己实现的实时器队列，详细的技术描述可以见这里，已有高人将其翻译成了中文：http://www.linuxforum.net/forum/showthreaded.php?Cat=&Board=driver&Number=385224&page=0&view=collapsed&sb=5&o
定时器队列time_list
hannick的专栏
11-01 2099
------------------------------- struct timer_list { struct list_head list; unsigned long expires; unsign
RT-Thread定时器源码分析
最新发布
06-09
首先，RT-Thread是一个实时操作系统，它提供了一些基本的实时操作系统功能，例如线程、信号量、消息队列、定时器等。其中，定时器是一种非常重要的实时操作系统功能，它可以用来在指定的时间间隔内执行一些操作。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值