开发者社区> 韩曙亮> 正文

【Android 异步操作】Timer 定时器 ( Timer 与 TimerTask 基本使用 | Timer 定时器常用用法 | Timer 源码分析 )

简介: 【Android 异步操作】Timer 定时器 ( Timer 与 TimerTask 基本使用 | Timer 定时器常用用法 | Timer 源码分析 )
+关注继续查看

文章目录

一、Timer 定时器基本使用

二、Timer 定时器常用用法

三、Timer 源码分析

四、Timer 部分源码注释

五、源码及资源下载



参考文档 :


Timer 定时器 API 文档

TimerTask 定时器任务 API 文档





一、Timer 定时器基本使用


Timer 可用于执行延迟任务或循环任务 ; 下面是定时器最基本用法 ;



1 . Timer 定时器基本使用 :


创建 Timer 定时器 : 调用构造函数创建定时器 Timer timer = new Timer() ;

分配 TimerTask 定时器任务 : 调用定时器的 schedule 方法 , 为 Timer 定时器分配 TimerTask 定时器任务 ;

   

timer.schedule(new TimerTask() {
            @Override
            public void run() {
                // ...
            }
        }, 1_000);



2 . 定时器任务执行规则 : Timer 执行任务是 串行执行 的 , 同一时间只能执行一个任务 ;


在下面的示例中


任务 1 在 1 秒之后执行 , 在第 6 秒执行完毕 ;

任务 2 在第 6 秒 , 任务 1 执行完毕后 , 才开始执行 , 在第 11 秒执行完毕 ;


3 . 代码示例 :


   

private void timer(){
        // Timer 可用于执行延迟任务或循环任务
        Timer timer = new Timer();
        /*
            如果提交多个 TimerTask 定时器任务
            需要等待之前的 定时器任务 执行完成 , 才能执行后面的任务
            TimerTask 实现了 Runnable 接口
            延迟 1 秒执行任务 1 ( 任务 1 时长 5 秒 )
            延迟 2 秒执行任务 2 ( 任务 2 时长 5 秒 )
            Timer 执行任务是串行执行的 , 同一时间只能执行一个任务
            任务 1 在 1 秒之后执行 , 在第 6 秒执行完毕
            任务 2 在第 6 秒 , 任务 1 执行完毕后 , 才开始执行 , 在第 11 秒执行完毕
         */
        // 延迟 1 秒执行任务 1
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Log.i(TAG, "延迟 1 秒执行 5 秒的任务 1 开始执行");
                try {
                    Thread.sleep(5_000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.i(TAG, "延迟 1 秒执行 5 秒的任务 1 执行完毕");
            }
        }, 1_000);
        // 延迟 2 秒执行任务 2
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Log.i(TAG, "延迟 2 秒执行 5 秒的任务 2 开始执行");
                try {
                    Thread.sleep(5_000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.i(TAG, "延迟 2 秒执行 5 秒的任务 2执行完毕");
            }
        }, 2_000);
    }







二、Timer 定时器常用用法


1 . Timer 定时器构造函数 :



① 创建默认定时器 : 默认以 “Timer-序列号” 作为定时器线程名称 ;


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


② 创建守护线程定时器 : 指定定时器是否作为守护线程来执行 , 定时器线程名称是默认名称 ;


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


③ 创建定时器并指定定时器名称 : 创建定时器 , 并 设置定时器线程名称 ;


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


④ 指定名称并设置守护线程 : 同时 设置定时器名称 , 并 设置定时器是否是守护线程 ;


 

public Timer(String name, boolean isDaemon) {
        thread.setName(name);
        thread.setDaemon(isDaemon);
        thread.start();
    }



2 . 定时器调度方法 :



① 在指定一段时间后执行定时器任务 : 在 delay 毫秒后 , 执行 TimerTask 定时器任务 ;


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


② 在指定的时间执行定时器任务 : 在某个指定的时间执行 TimerTask 定时器任务 ;


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


③ 在指定的时间执行循环任务 : 在 firstTime 时间执行第一次 TimerTask 定时器任务 , 之后每隔 period 毫秒的周期时间 , 循环执行定时器任务 ; 循环周期是 period 毫秒 ; 如果因为某种原因导致某些操作出现了延迟 , 那么后续操作也会跟着延迟 ;


 

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


④ 延迟指定时间循环执行任务 : 延迟 delay 毫秒后 , 执行第一次定时器任务 , 然后每隔 period 毫秒 , 循环执行定时器任务 ; 循环周期是 period 毫秒 ; 如果因为某种原因导致某些操作出现了延迟 , 那么后续操作也会跟着延迟 ;


   

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);
    }


⑤ 在指定的时间执行循环任务 : 在 firstTime 时间执行第一次 TimerTask 定时器任务 , 之后每隔 period 毫秒的周期时间 , 循环执行定时器任务 ; 循环周期是 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);
    }


⑥ 延迟指定时间循环执行任务 : 延迟 delay 毫秒后 , 执行第一次定时器任务 , 然后每隔 period 毫秒 , 循环执行定时器任务 ; 循环周期是 period 毫秒 ; 如果因为某种原因导致某些操作出现了延迟 , 那么后续操作需要补偿上述出现的延迟 ;


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




schedule 方法适用场景 : 适合用于平稳执行某种任务 ; 稳定性 > 准确率 ;


scheduleAtFixedRate 方法适用场景 : 适合用于对绝对时间敏感的任务 ; 准确率 > 稳定性 ;






三、Timer 源码分析


在 Timer 中定义了 TimerThread thread 成员变量 , 该成员对象在创建对象时会自动创建 ;


TimerThread 是定义在 Timer.java 文件中的类 , 是一个自定义线程类 ; 该帮助类实现了定时器任务的执行线程 , 该线程中的定时器队列等待任务到来 , 在合适的时间执行定时器任务 ; 调度需要重复执行的任务 ; 从任务队列中 , 移出被取消的任务 , 移出不需要循环执行的任务 ;


class TimerThread extends Thread{}


在构造函数 public Timer(String name) 中 , 调用了该线程的 start() 方法 , 启动了该线程 ;


// 省略了无关代码 
public class Timer {
    private final TimerThread thread = new TimerThread(queue);
    public Timer(String name) {
        // 启动 TimerThread 线程 
        thread.start();
    }
}



在 TimerThread 自定义线程中的 run() 方法中 , 主要是调用了 mainLoop() 方法 ; 该方法中是一个死循环 , 从循环队列中取出 TimerTask 定时器任务 , 然后执行 ; 必须等待前一个任务执行完毕 , 才能执行下一个任务 ;







四、Timer 部分源码注释


// 省略了无关代码 
public class Timer {
    /**
     * 定时器线程 
     * 该 TimerThread thread 对象在创建对象时会自动创建 
     */
    // Android-added: @ReachabilitySensitive
    @ReachabilitySensitive
    private final TimerThread thread = new TimerThread(queue);
    // 生成序列号 , 作为定时器线程的默认名称 
    private static int serialNumber() {
        return nextSerialNumber.getAndIncrement();
    }
    /**
     * 创建默认定时器 , TimerThread thread 成员变量不作为守护线程
     */
    public Timer() {
        this("Timer-" + serialNumber());
    }
    /**
     * 创建一个定时器 , 其关联的 TimerThread thread 成员可以设置是否作为守护线程 ;
     * 如果该定时器用于用于调度重复性的维护活动 , 其守护线程会被调用 , 
     * 应用运行期间必须调用守护线程 , 
     * 但是上述操作不能影响应用的生命周期 ; 
     *
     * @param isDaemon 如果设置成 true , TimerThread thread 需要被设置成守护线程 
     */
    public Timer(boolean isDaemon) {
        this("Timer-" + serialNumber(), isDaemon);
    }
    /**
     * 创建一个 Timer 定时器 , 并为其其关联的线程设置指定的名称 ; 
     *
     * @param name 为 TimerThread 成员变量设置名称
     */
    public Timer(String name) {
        thread.setName(name);
        // 启动 TimerThread 线程 
        thread.start();
    }
    /**
     * Creates a new timer whose associated thread has the specified name,
     * and may be specified to
     * {@linkplain Thread#setDaemon run as a daemon}.
     *
     * @param name 设置关联的定时器线程名称
     * @param isDaemon 如果设置成 true 定时器线程将被设置成守护线程
     */
    public Timer(String name, boolean isDaemon) {
        thread.setName(name);
        thread.setDaemon(isDaemon);
        thread.start();
    }
}
/**
 * TimerThread 是定义在 Timer.java 文件中的类 ; 
 * 
 * 该帮助类实现了定时器任务的执行线程 , 该线程中的定时器队列等待任务到来 , 在合适的时间执行定时器任务 ; 
 * 调度需要重复执行的任务 ;
 * 从任务队列中 , 移出被取消的任务 , 移出不需要循环执行的任务 ; 
 */
class TimerThread extends Thread {
    /**
     * 该标志为会 被 reaper  设置成 false , 用于通知我们定时器对象已经被销毁 ; 
     * 一旦该标志位设置成 true , 并且任务队列中没有任务时 , 没有任务去执行 , 这里就需要优雅的关闭定时器 ; 
     * 注意该字段由队列管理器维护 ; 
     */
    boolean newTasksMayBeScheduled = true;
    /**
     * 任务队列 , 调用 schedule 方法调度 TimerTask 定时器任务 , 就是将任务加入到该队列中 ; 
     * 定时器任务队列 , 在定时器线程中维护该队列 , 而不是在定时器中维护 , 这样避免循环引用 ; 
     * 否则定时器永远不会被回收 , 并且该线程永远不会消失 ; 
     */
    private TaskQueue queue;
    TimerThread(TaskQueue queue) {
        this.queue = queue;
    }
    // run 方法中主要是调用 mainLoop() 方法 ; 
    public void run() {
        try {
            mainLoop();
        } finally {
            // 如果定时器被取消 , 需要杀死该线程
            synchronized(queue) {
                newTasksMayBeScheduled = false;
                queue.clear();  // 消除过时的引用
            }
        }
    }
    /**
     * 定时器轮询 
     * 里面是一个死循环 , 循环从人物队列中取出 TimerTask 定时器任务 , 然后执行 ; 
     * 必须等待前一个任务执行完毕 , 才能执行下一个任务 
     */
    private void mainLoop() {
        while (true) {
            try {
                TimerTask task; // 定时器任务 
                boolean taskFired; 
                synchronized(queue) {
                    // 如果队列为空 , 一直阻塞 , 当有任务进来时 , 解除阻塞
                    while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                    if (queue.isEmpty())
                        break; // 如果队列为空 , 就会退出循环 , 终止该定时器 
                    // 队列不为空 , 查看第一个 evt , 并执行相应操作 
                    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) {
            }
        }
    }
}






五、源码及资源下载


源码及资源下载地址 :


① GitHub 工程地址 : Android_Asynchronous


② MainActivity.java 主界面代码地址 : MainActivity.java , 这是上述示例代码位置 ; 仅做参考意义不大 ;


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
HBase基本操作-shell使用
这篇在学习之前,需要搭建好HBase集群,当你的集群搭建好了,那么就开始学习HBase的shell操作把~ 这篇文章将只会介绍使用频率最高的shell命令,这些没有什么难度,只是一些熟练问题,我的HBase版本是 进入HBase的命令行的命令是HBase shell 查看HBase shell中.
7069 0
easy-task基础入门使用说明
easy-task基础入门使用说明
20 0
C#.NET使用Task,await,async,异步执行控件耗时事件(event),不阻塞UI线程和不跨线程执行UI更新,以及其他方式比较
原文:C#.NET使用Task,await,async,异步执行控件耗时事件(event),不阻塞UI线程和不跨线程执行UI更新,以及其他方式比较 使用Task,await,async,异步执行事件(event),不阻塞UI线程和不跨线程执行UI更新   使用Task,await,async 的异步模式 去执行事件(event) 解决不阻塞UI线程和不夸跨线程执行UI更新报错的最佳实践,附加几种其他方式比较 由于是Winform代码和其他原因,本文章只做代码截图演示,不做界面UI展示,当然所有代码都会在截图展示。
3656 0
sublime 的使用|学习笔记
快速学习 sublime 的使用
28 0
[Chromium]如何安全的使用PostTask
PostTask参数决策树 如何传递绑定的对象 官方的解释总是最权威,有疑问看这里或者直接看代码中的说明: bind_helpers.h.  传值方式 描述 this 或 对象指针 如果对象本身是一个RefCountedThread...
1265 0
使用Timer和ScheduledThreadPoolExecutor执行定时任务
定时任务是在指定时间执行程序,或周期性执行计划任务。Java中实现定时任务的方法有很多,主要JDK自带的一些方法以及开源程序如Qurtz。
3704 0
Linux内核定时器--timer_list
Linux内核定时器--timer_list
97 0
+关注
韩曙亮
专注 Android 领域
2605
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
JS零基础入门教程(上册)
立即下载
性能优化方法论
立即下载
手把手学习日志服务SLS,云启实验室实战指南
立即下载