android 日期计时器 android 计时器实现

转载

技术极客 2024-05-23 17:15:51

文章标签 android 日期计时器 Android 定时 Handler AlarmManager 文章分类 Android 移动开发

前言

这几天正在看Android官方的开发文档，里面有很多很值得思考的开发建议，有时间的朋友可以去看一下（官方是英文文档，如果看不懂可以通过浏览器插件翻译对比着看，还是很方便的）。

其中一篇课程提到了AlarmManager，这个类之前仅仅是了解这是一个闹钟的管理器，如果要是做一些胜过提醒、闹钟之类的软件都需要用到。官方的例子用来实现定时器，突然觉得这是一个很神奇的事情，就搜集了一些资料，把我知道的实现计时器的几种方法写下来，给自己加深记忆，也分享给大家。

Android消息机制

首先来了解一下Android的消息处理机制

即Handlerd的运行机制，handler的运行需要底层的MessageQueue和Looper的支撑。MessageQueue（消息队列），它的内部存储了一些消息，以队列的形式对外提供插入和删除的操作（实际为单链表存储）。Looper(消息循环），配合MessageQueue实现实现消息的不断入队和出队工作。

一个关系图：

android 日期计时器 android 计时器实现_AlarmManager

通过Handler可以很容易将任务切换到其他线程中执行，以减少主线程的负担，因此Handler常用来进行UI更新。这里只是简单的进行一些概述。对应handler还不清楚的强烈建议参考以下博客：
Android 异步消息处理机制
 Android AsyncTask完全解析

当然，现在已经有更好的消息处理办法了，了解handler和Asynctask可以更好的理解Android内部消息的处理机制。
推荐：EventBus，高度解耦，代码简洁明了，有兴趣的可以自行参考使用。

正文

我用到的几种实现定时器的类：Handler， Timer， Thread, AlarmManager。

AlarmManager

AlarmManager是系统开放的闹钟功能，使用方式和普通的manager没有区别。

AlarmManager am = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);  
// Schedule the alarm!  
Intent intent = new Intent(XXXXX);
PendingIntent sender = PendingIntent.getBroadcast(mcontext,requestCode, intent, 0);  
am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,  
                         firstTime, 30*1000, sender);

上面就是定时器的基本用法，先获取manager，然后定义闹钟的flag，循环时间，到指定时间发出的pendingIntent。

一般都发出的pendingIntent都是广播，我们自定义一个广播接收器，就可以通过接收这个广播，来处理自己的功能逻辑了。

这里需要注意在独立进程中配置，这是android所定义的

<receiver android:name="com.xxxx.Receiver" android:process=":remote" />

优点总结

1，Alarm定时不需要程序自身去维护，而又系统来维护，使得程序更好避免了容易出错问题，更是占用系统资源，cpu占有率。

2，即使程序退出后，程序自身不会有任何烦恼的问题，系统到时间自动调用对应组件执行定义好的逻辑

3，定时的多样性，包括一次定时，循环定时（在xx年x月x日执行，周一至周五执行，每天几点几分执行。。。）

适用场景

个人觉得比较适用于独立的功能逻辑，例如如果app需要定时从服务器抓取最新的数据，使用独立的service会与主体的功能分离、便于维护，关键是耗电低，不易出错。

Handler

Handler可以帮助我们在子线程中操作UI线程，例如子线程解析数据，解析结束后通知UI刷新界面。他本身也可以实现定时器。

private Handler handler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case 0:
                // 移除所有的msg.what为0等消息，保证只有一个循环消息队列再跑
                handler.removeMessages(0);
                // app的功能逻辑处理
                ...
                // 再次发出msg，循环更新
                handler.sendEmptyMessageDelayed(0, 1000);
                break;

            case 1:
                // 直接移除，定时器停止
                handler.removeMessages(0);
                break;

            default:
                break;
            }
        };
    };

只要在启动定时器的时候，Handler.sendEmptyMessage(0)，定时器就启动了。继续循环和停止的方法，注释上已经写了。

优点总结

每次循环都是在主线程中操作，避免了子线程和主线程之间的穿插交互，个人觉得比timer好控制，功能实现也很简单。

适用场景

个人觉得比较适用连续更新UI，不做复杂耗时的处理的情况，例如在播放器中，我们需要更新当前播放进度的时间的显示，仅仅是更新了文字显示，用handler就是个不错的选择。

Timer

Timer是Android直接启动定时器的类，也是我最早接触可以实现定时器的功能的工具类。

他的用法一般人都知道：

// 初始化定时器
Timer timer = new Timer();
timer.schedule(new TimerTask() {

    @Override
    public void run() {
        Log.e("lzp", "timer excute");
    }
}, delay, period);

// 停止定时器
private void stopTimer(){
    if(timer != null){
        timer.cancle();
        // 一定设置为null，否则定时器不会被回收
        timer = null;
    }
}

delay : 从定时器初始化成功开始启动的延迟时间。
period：定时器的间隔时间。

优点总结

Timer的使用很简单，TimerTask是一个子线程，方便处理一些比较复杂耗时的功能逻辑，经常与handler结合使用。

适用场景

跟handler自身实现的定时器相比，Timer可以做一些复杂的处理，例如，需要对有大量对象的list进行排序，在TimerTask中执行不会阻塞子线程，常常与handler结合使用，在处理完复杂耗时的操作后，通过handler来更新UI界面。

**特别吐槽：对于部分手机，如果你在TimerTask直接更新了UI线程是不会报错的，而且运行正常，但是一定注意，更新UI一定要在主线程中执行，否则排查错误的时候你懂得。而且这个东西特别耗电，特别耗电，特别耗电，重要的事情说三遍，一定在不使用的时候关闭，慎用。
**

Thread

Thread实现定时器是创建一个子线程，在里面while循环，可以通过handler来更新UI。个人觉得Thread和Timer没区别，只是长得不一样。

private MyThread thread;

    private class MyThread extends Thread {

        public boolean stop;

        public void run() {
            while (!stop) {
                // 处理功能

                // 通过睡眠线程来设置定时时间
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
    };

    /**
     * 启动线程
     * */
    private void start() {
        if (thread == null) {
            thread = new MyThread();
            thread.start();
        }
    }

    /**
     * 停止线程
     * */
    private void stop() {
        if (thread != null) {
            thread.stop = true;
            thread = null;
        }
    }

优点总结

觉得跟Timer差不多，没什么特殊优点

适用场景

跟Timer差不多吧，多线程如果考虑不周经常会出问题，经常会出现多个相同功能的线程同时存在，android本身对于子线程的使用使用数量是有限制的，而且一个app同时跑多个线程是一个很可怕的事情，所以和Timer一样，使用的时候一定要谨慎考虑。

1.采用Handle与线程的sleep(long)方法

1）定义一个Handler类，用于处理接受到的Message。

Handler handler = new Handler() {  
    public void handleMessage(Message msg) {  
        // 要做的事情  
        super.handleMessage(msg);  
    }  
};

2）新建一个实现Runnable接口的线程类，如下：

public class MyThread implements Runnable {  
    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        while (true) {  
            try {  
                Thread.sleep(10000);// 线程暂停10秒，单位毫秒  
                Message message = new Message();  
                message.what = 1;  
                handler.sendMessage(message);// 发送消息  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    }  
}

3）在需要启动线程的地方加入下面语句：

new Thread(new MyThread()).start();

分析：纯正的java原生实现，在sleep结束后，并不能保证竞争到cpu资源，这也就导致了时间上必定>=10000的精度问题。

2.采用Handler的postDelayed(Runnable, long)方法

1）定义一个Handler类

Handler handler=new Handler();  


Runnable runnable=new Runnable() {  
    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        //要做的事情  
        handler.postDelayed(this, 2000);  
    }  
};

2）启动与关闭计时器

handler.postDelayed(runnable, 2000);//每两秒执行一次runnable.

handler.removeCallbacks(runnable);

分析：嗯，看起蛮不错，实现上也简单了，和sleep想必还不会产生阻塞，注意等待和间隔的区别。

3.采用Handler与timer及TimerTask结合的方法

1）定义定时器、定时器任务及Handler句柄

private final Timer timer = new Timer();  
private TimerTask task;  
Handler handler = new Handler() {  
    @Override  
    public void handleMessage(Message msg) {  
        // TODO Auto-generated method stub  
        // 要做的事情  
        super.handleMessage(msg);  
    }  
};

2）初始化计时器任务

task = new TimerTask() {  
    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        Message message = new Message();  
        message.what = 1;  
        handler.sendMessage(message);  
    }  
};

3）启动和关闭定时器

timer.schedule(task, 2000, 3000);

timer.cancel();

此外，Timer也可以配合runOnUiThread实现，如下

private TimerTask mTimerTask = new TimerTask() {
        @Override
        public void run() {

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    //处理延时任务
                }
            });
        }
    };

分析：timer.schedule(task, 2000, 3000);意思是在2秒后执行第一次，之后每3000秒在执行一次。timer不保证精确度且在无法唤醒cpu,不适合后台任务的定时。

采用AlarmManger实现长期精确的定时任务

AlarmManager的常用方法有三个：

set(int type，long startTime，PendingIntent pi)；//一次性
setExact(int type, long triggerAtMillis, PendingIntent operation)//一次性的精确版
setRepeating(int type，long startTime，long intervalTime，PendingIntent
pi)；//精确重复
setInexactRepeating（int type，long startTime，long
intervalTime，PendingIntent pi）；//非精确，降低功耗

type表示闹钟类型，startTime表示闹钟第一次执行时间，long intervalTime表示间隔时间，PendingIntent表示闹钟响应动作

对以上各个参数的详细解释
闹钟的类型：

AlarmManager.ELAPSED_REALTIME：休眠后停止，相对开机时间
AlarmManager.ELAPSED_REALTIME_WAKEUP：休眠状态仍可唤醒cpu继续工作，相对开机时间
AlarmManager.RTC：同1，但时间相对于绝对时间
AlarmManager.RTC_WAKEUP：同2，但时间相对于绝对时间
AlarmManager.POWER_OFF_WAKEUP：关机后依旧可用，相对于绝对时间

绝对时间：1970 年 1月 1 日 0 点

startTime：
闹钟的第一次执行时间，以毫秒为单位，一般使用当前时间。

SystemClock.elapsedRealtime()：系统开机至今所经历时间的毫秒数
System.currentTimeMillis()：1970 年 1 月 1 日 0 点至今所经历时间的毫秒数

intervalTime：执行时间间隔。

PendingIntent ：
PendingIntent用于描述Intent及其最终的行为.，这里用于获取定时任务的执行动作。
详细参考译文：PendingIntent

利用AlarmManger+Service+BarocastReceiver实现5s一次打印操作

服务类：

public class HorizonService extends Service {
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d("TAG", "打印时间: " + new Date().
                        toString());
            }
        }).start();
        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
        int five = 5000; // 这是5s
        long triggerAtTime = SystemClock.elapsedRealtime() + five;
        Intent i = new Intent(this, AlarmReceiver.class);
        PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
        return super.onStartCommand(intent, flags, startId);
    }
}

广播接受器

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context, HorizonService.class);
        context.startService(i);
    }
}

启动定时任务：

Intent intent = new Intent(this,HorizonService.class);
startService(intent);

效果Demo:

android 日期计时器 android 计时器实现_定时_02

本例通过广播接收器和服务的循环调用实现了无限循环的效果，当然，你也可以直接利用setRepeating实现同样的效果。

注意：不要忘了在manifest文件中注册服务和广播接收器。

AlarmManager的取消方法：AlarmManger.cancel();

分析：该方式可唤醒cpu甚至实现精确定时，适用于配合service在后台执行一些长期的定时行为。

本文总结：不建议使用第一种方式，短期的定时任务推荐第二、三种方式实现，长期或者有精确要求的定时任务则可以配合Service在后台执行。

有其他疑问可下方提出或者直接链接官方文档AlarmService

AlarmManager-系统推荐的定时任务

近期leader提了很多这样的需求：每隔几个小时拉取服务器的配置信息存在本地、每隔一段时间跟服务端校对一下本地时间、每隔一段时间上传一下本地日志等等。其实这些本质都是定时任务，隔一段时间去干xxx，那...

结尾

以上就是我个人使用过的定时器的几种实现的方法，但是都仅仅是简单的介绍，更为详细的用法在网上有很多相关的资料，如果有错误，欢迎留言批评指正，希望看完这篇文章能对你有所帮助。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：抓取图片 android 抓取图片快捷键

下一篇：超参数优化在图像分类中应用超参数调优

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯