Timer源码剖析

最新推荐文章于 2024-08-30 20:58:38 发布
最新推荐文章于 2024-08-30 20:58:38 发布
阅读量141 收藏
点赞数
文章标签： python 移动开发 数据结构与算法
原文链接：https://my.oschina.net/u/3342652/blog/1486418
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1、Timer概述

Timer类我们通常用来执行延迟、定时任务，与其密切相关的类有TimerTask、TaskQueue、TimerThread。与Android的消息机制类似，timer.schedule()不断的将任务扔到TaskQueue中，TimerThread用于不断的循环任务队列执行任务。

人傻话少，裁剪别人写的。

170555_quuI_3342652.png

2、任务的执行顺序是否和代码中写的一致？

private void sched(TimerTask task, long time, long period) {
    if (time < 0) throw new IllegalArgumentException("Illegal execution time.");
    if (Math.abs(period) > (Long.MAX_VALUE >> 1)) period >>= 1;
    synchronized (queue) {
        if (!thread.newTasksMayBeScheduled)
             throw new IllegalStateException("Timer already cancelled.");
        synchronized (task.lock) {
            if (task.state != TimerTask.VIRGIN)
                throw new IllegalStateException("Task already scheduled or cancelled");
            task.nextExecutionTime = time;
            task.period = period;
            task.state = TimerTask.SCHEDULED;
        }
        queue.add(task);
        if (queue.getMin() == task) queue.notify();
    }
}

当一个任务加到队列中时加了锁，所以多次执行schedule( )代码添加任务，Timer并不能保证任务执行的先后顺序是按照代码中写的顺序。

public class JavaMain {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new Task(1), 0);
        timer.schedule(new Task(2), 0);
        timer.schedule(new Task(3), 0);
        timer.schedule(new Task(4), 0);
        timer.schedule(new Task(5), 0);
        timer.schedule(new Task(6), 0);
        timer.schedule(new Task(7), 0);
    }

    static class Task extends TimerTask {
        private int index = 0;

        Task(int i) {
            index = i;
        }

        @Override
        public void run() {
            System.out.println("hell world! = " + index);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果：

hell world! = 1
hell world! = 7
hell world! = 6
hell world! = 5
hell world! = 4
hell world! = 3
hell world! = 2

113034_tlpf_3342652.png

3、源码分析

// 用于创建任务
public class Timer {

    private final TaskQueue queue = new TaskQueue();
    private final TimerThread thread = new TimerThread(queue);

    // 以自增形式，标记任务名称
    private final static AtomicInteger nextSerialNumber = new AtomicInteger(0);

    private static int serialNumber() {
        return nextSerialNumber.getAndIncrement();
    }

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

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

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

    /**
     * 是否守护线程
     *
     * @param name
     * @param isDaemon
     */
    public Timer(String name, boolean isDaemon) {
        thread.setName(name);
        thread.setDaemon(isDaemon);
        thread.start();
    }

    public void schedule(TimerTask task, long delay) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        sched(task, System.currentTimeMillis() + delay, 0);
    }

    public void schedule(TimerTask task, Date time) {
        sched(task, time.getTime(), 0);
    }

    public void schedule(TimerTask task, long delay, long period) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, System.currentTimeMillis() + delay, -period);
    }

    public void schedule(TimerTask task, Date firstTime, long period) {
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, firstTime.getTime(), -period);
    }

    public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, System.currentTimeMillis() + delay, period);
    }

    public void scheduleAtFixedRate(TimerTask task, Date firstTime,
                                    long period) {
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, firstTime.getTime(), period);
    }

    /**
     * 添加任务，原子操作
     *
     * @param task
     * @param time
     * @param period
     */
    private void sched(TimerTask task, long time, long period) {
        if (time < 0) throw new IllegalArgumentException("Illegal execution time.");
        if (Math.abs(period) > (Long.MAX_VALUE >> 1)) period >>= 1;
        synchronized (queue) {
            if (!thread.newTasksMayBeScheduled) 
                throw new IllegalStateException("Timer already cancelled.");
            synchronized (task.lock) {
                if (task.state != TimerTask.VIRGIN)
                    throw new IllegalStateException("Task already scheduled or cancelled");
                task.nextExecutionTime = time;
                task.period = period;
                task.state = TimerTask.SCHEDULED;
            }
            queue.add(task);
            if (queue.getMin() == task) queue.notify();
        }
    }

    /**
     * 将queue所有任务置为null.
     */
    public void cancel() {
        synchronized (queue) {
            thread.newTasksMayBeScheduled = false;
            queue.clear();
            queue.notify();  // In case queue was already empty.
        }
    }

    /**
     * 将所有状态为CANCELLED的任务从queue中移除
     *
     * @return
     */
    public int purge() {
        int result = 0;
        synchronized (queue) {
            for (int i = queue.size(); i > 0; i--) {
                if (queue.get(i).state == TimerTask.CANCELLED) {
                    queue.quickRemove(i);
                    result++;
                }
            }
            if (result != 0) queue.heapify();
        }
        return result;
    }
}
// 用于封装一个任务
public abstract class TimerTask implements Runnable {

    final Object lock = new Object();

    int state = VIRGIN;

    static final int VIRGIN = 0;

    static final int SCHEDULED = 1;        // 排定

    static final int EXECUTED = 2;        // 执行

    static final int CANCELLED = 3;        // 取消

    long nextExecutionTime;   // 运行点

    long period = 0;

    protected TimerTask() {
    }

    public abstract void run();

    public boolean cancel() {
        synchronized (lock) {
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }

    public long scheduledExecutionTime() {
        synchronized (lock) {
            return (period < 0 ? nextExecutionTime + period
                    : nextExecutionTime - period);
        }
    }
}

164540_UBbr_3342652.jpg

// 用于存储任务
public class TaskQueue {
    /**
     * 以数组的形式，维护的是一个平衡二叉树
     */
    private TimerTask[] queue = new TimerTask[128];
    private int size = 0;   // 没有 queue[0] ，应该是为了方便记忆

    int size() {
        return size;
    }

    void add(TimerTask task) {
        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;
        fixDown(1);
    }

    // 移除并未并做调整
    void quickRemove(int i) {
        assert i <= size;
        queue[i] = queue[size];
        queue[size--] = null;
    }

    void rescheduleMin(long newTime) {
        queue[1].nextExecutionTime = newTime;
        fixDown(1);
    }

    boolean isEmpty() {
        return size == 0;
    }

    void clear() {
        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++; 
            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);
    }
}
// 用于执行未执行任务
public class TimerThread extends Thread {

    boolean newTasksMayBeScheduled = true;

    private TaskQueue queue;

    TimerThread(TaskQueue queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            mainLoop();
        } finally {
            synchronized (queue) {
                newTasksMayBeScheduled = false;
                queue.clear();
            }
        }
    }

    // 核心代码
    private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized (queue) {
                    /**
                     * 线程启动后并未执行，等待queue.notify()，以免做无用功
                     */
                    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) {
                    task.run();
                }
            } catch (InterruptedException e) {
            }
        }
    }
}

cancle与purge区别

/**
 * 清空任务队列
 */
public void cancel() {
    synchronized(queue) {
        thread.newTasksMayBeScheduled = false;
        queue.clear();
        queue.notify();  // In case queue was already empty.
    }
}
/**
 * 将所有标志位CANCELLED状态的任务移除掉
 */
public int purge() {
    int result = 0;

    synchronized(queue) {
        for (int i = queue.size(); i > 0; i--) {
            if (queue.get(i).state == TimerTask.CANCELLED) {
                queue.quickRemove(i);
                result++;
            }
        }

        if (result != 0)
            queue.heapify();
    }

    return result;
}

转载于:https://my.oschina.net/u/3342652/blog/1486418

weixin_33939380
关注
【FastDDS源码剖析】Timer
桃花朵朵的博客
01-12 246
本文将对Fast DDS定时器源码进行分析。定时器是实时通信系统中一项重要的功能，用于管理和触发各种时间相关的任务和事件。在实时通信中，时间敏感性是至关重要的。定时器作为一种关键机制，为Fast DDS提供了在特定时间点执行任务的能力。它可以用于处理数据发送和接收的超时、重传机制、心跳检测、资源管理等多种场景。通过合理使用定时器，Fast DDS能够确保数据的及时传输、资源的高效利用以及系统的稳定性。本文将深入研究Fast DDS定时器的实现细节和关键功能。
【009】 mongoose V7.4源码剖析之创建监听套接字fd
专注【PostgreSQL源码学习&研究】
10-12 486
文章目录1. mg_connection结构声明 1. mg_connection结构声明 在继续本篇及之后的系列文章阅读之前，强烈建议先去回顾之前我这边写的几篇文章，这能帮你快速地熟悉mongoose服务，包括其内部重要数据结构、大致工作原理等。 《mongoose 6.14源码剖析之基础篇（一）》 《mongoose 6.14源码剖析之创建管理句柄（二）》 《mongoose 6.14源码剖析之绑定监听端口（三）》 社区一直在维护着mongoose源码，并且版本更新较为频繁，并且每次大版本的迭代更新，都
《Java源码分析》：Timer/TimerTask
wojiushimogui的博客
08-05 2537
《Java源码分析》：Timer在JDK 5.0之前，java.util.Timer/TimerTask是唯一的内置任务调度方法，而且在很长一段时间里很热衷于使用这种方式进行周期性任务调度。本篇博文就先使用Timer/TimerTask来完成任务的调度。接着再来分析Timer/TimerTask的源码。Timer类中常见方法1、void cancel() 终止此计时器，丢弃所
Timer源码分析
白嫩豆腐
04-01 1004
前言Timer是个轻量级的定时控件，一般项目中不太常见，对于普通业务一般可以用handler或者alarmmaager来实现，但是最近研究thread。就看了下Timer类。忽然发现设计也是很优秀的。这里就对这个控件进行了分析
Timer的源码分析
jwcjlu的专栏
08-17 279
这段时间用到了Timer做一个定时任务，因为业务的原因就需要调计算机的时间，发现一个问题把时间先调大于当前时间在调回来发现timer就没有执行了，感觉Timer不会这么坑吧，所以就看了一下源码。下面就把我理解Timer的分享一下        先看Timer类的结构里面内置二个重要的组件TimerThread（定时线程）和TaskQueue（任务队列）下面是Timer的部分源码   我
Java Timer源码解析（定时器源码解析）
许佳佳的博客
10-20 1321
Timer概述 Timer顾名思义就是定时器，用于处理一些需要延时处理的任务，延时时间可能是1s，也可能是5天。 一般使用方式如下： TimerTask task = new TimerTask() { @Override public void run() { Log.d("test", "timer...
Java Timer 源码深入分析
热门推荐
键盘上流淌的日子
07-19 1万+
源码均以JDK1.8作为参考 JDK1.3中为定时任务提供了一种简单实现，java.util.Timer类调度java.util.TimerTask任务。 TimerTask： TimerTask为Timer定时任务的执行提供了最小执行单元，TimerTask继承自Runnable接口，TimerTask本身是一个抽象类，给继承自Runnable接 口的TimerTask更加详细的
OSG中与时间相关的类osg::FrameStamp,osg::Timer源码剖析
09-17 3144
这次分析一下OSG中的的
Vue源码剖析
weixin_39963436的博客
01-24 404
响应式原理 Vue源码获取: Vue 2.6 ： https://github.com/vuejs/vue Vue 3.0：https://github.com/vuejs/vue-next Vue.js 的静态成员和实例成员初始化过程 首次渲染的过程 数据响应式原理 虚拟 DOM 模板编译和组件
Bluedroid bta_gattc_start_discover源码剖析
最新发布
byte轻骑兵的博客
08-30 1447
当BLE设备作为GATT客户端（GATT Client）连接到GATT服务器（GATT Server）后，它通常需要执行发现过程以了解服务器的GATT数据库结构。这包括服务（Services）、特征（Characteristics）和描述符等。函数正是用于启动这一过程的。
OpenMv教程由入门到精通
01-11
OpenMv教程由入门到精通
Java Timer/TimerTask 源码解析
博学笃志-格物明德
06-25 629
。
jdk源码之定时器Timer源码解析
drop616的博客
12-27 735
定时器Timer源码解析 一 Timer 1、Timer Timer较之Quartz结构相对简单，其原理更容易动，并且两个会有相似之处，可以在了解Timer之后在看Quartz可能会相对容易通透一点，在Quartz之前先了解一下Timer定时器，以下是JDK Api中的介绍： 线程调度任务以供将来在后台线程中执行的功能。 任务可以安排一次执行，或定期重复执行。 对应于每个Timer对象是单个后台线程，用于依次执行所有定时器的所有任务。 计时器任务应该快速完成。 如果一个定时器任务需要花费很多时间来完成，
【源码】Timer和TimerTask源码剖析
RowandJJ
08-26 2310
Timer是java.util包中的一个工具类，提供了定时器的功能。我们可以构造一个Timer对象，然后调用其schedule方法在某个特定的时间或者若干延时之后去执行一个特定的任务，甚至你可以让其以特定频率一直执行某个任务，这个任务用TimerTask描述，我们将需要的操作写在TimerTask类的run方法中即可。 本着“知其然，知其所以然”的心态，我决定研究下这个类的源码。 打开
任务调度之Timer定时器源码分析
Pushkin.的博客
11-12 772
任务调度之Timer定时器源码分析
Timer机制源码浅析
weixin_34090643的博客
03-27 99
作者：点先生 时间：2019.3.27 逼逼两句 Q：定时、延时任务有几种方式可以实现？ A：Handler、Timer、ScheduledThreadPool、AlarmManager Handler机制大家应该都烂熟于心了，今天我来讲讲Timer这个不常被问到的定时器。 改日再说线程池，预计是周日。 Timer机制包含了四个主要核心类：Timer，TaskQueue，TimerThread...
timer源码分析
weixin_30244889的博客
09-18 135
void add_timer(struct timer_list *timer) { BUG_ON(timer_pending(timer)); mod_timer(timer, timer->expires); } ====> int mod_timer(struct timer_list *timer, unsigned long expires) ...
libevent源码详解：深度剖析与关键功能
本文档深入剖析了libevent源码，这是一款广泛用于网络编程的高效事件驱动库，特别适用于需要处理大量并发I/O请求的场景。作者张亮通过一系列的文章，旨在提供对libevent核心功能、设计模式以及内部实现的详尽解读。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值