其实是定时周期性任务

本文将介绍五种 Android 实现倒计时的方法，对就是发送短信验证码后的倒计时那种。其实就是执行定时周期性的任务的五种方式，包括但不限于实现倒计时功能。这五种方式分别是：

handler+postDelayed() 方式
Timer + TimerTask + handler 方式
ScheduledExecutorService + handler 方式
RxJava 方式
CountDownTimer 方式

其中 Timer 的方式实现定时任务，这儿用来做倒计时是没有问题的。但是如果用来执行周期任务，恰好又有多个任务，恰好两个任务之间的时间间隔又比前一个任务执行时间短就会发生定时不准确的现象了。Timer 在执行过程中如果任务跑出了异常，Timer 会停止所有的任务。Timer 执行周期任务时依赖系统时间，系统时间的变化会引起 Timer 任务执行的变化。额。。。。问题貌似还挺多，所以我们用其他四种方式吧（手动滑稽）。

自定义的 handler

几种方式都会用到的 handler 放前面,避免 handler 引起的内存泄露，使用 handler 时建议按如下方式让 handler 持有一个当前 Activity 的弱引用：

    /**
     * handler 持有当前 Activity 的弱引用防止内存泄露
     */
    private static class LooperHandler extends Handler {
        WeakReference<LoopersActivity> mWeakReference;

        LooperHandler(LoopersActivity activity) {
            mWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            LoopersActivity loopersActivity = mWeakReference.get();
            switch (msg.what) {
                case 0:  
                    loopersActivity.mTvValue.setText(String.valueOf(TOTAL_TIME_SEC));
                    if (TOTAL_TIME_SEC <= 0) {
                        loopersActivity.scheduled.shutdown();
                        loopersActivity.mTvValue.setText(loopersActivity.getResources().getString(R.string.done));
                        loopersActivity.mStart.setEnabled(true);
                        loopersActivity.mStart.setBackgroundColor(Color.parseColor("#f97e7e"));
                    }
                    TOTAL_TIME_SEC--;
                    break;
                case 1:
                    loopersActivity.mTvValue.setText(String.valueOf(TOTAL_TIME_SEC));
                    if (TOTAL_TIME_SEC <= 0) {
                        loopersActivity.timer.cancel();
                        loopersActivity.timer = null;
                        loopersActivity.mTvValue.setText(loopersActivity.getResources().getString(R.string.done));
                        loopersActivity.mStart.setEnabled(true);
                        loopersActivity.mStart.setBackgroundColor(Color.parseColor("#f97e7e"));
                    }
                    TOTAL_TIME_SEC--;
                    break;
                case 2:
                    loopersActivity.mHandler.postDelayed(loopersActivity.mRunnable, ONECE_TIME);
                    loopersActivity.mTvValue.setText(String.valueOf(TOTAL_TIME_SEC));
                    if (TOTAL_TIME_SEC <= 0) {
                        loopersActivity.mHandler.removeCallbacks(loopersActivity.mRunnable);
                        loopersActivity.timer = null;
                        loopersActivity.mTvValue.setText(loopersActivity.getResources().getString(R.string.done));
                        loopersActivity.mStart.setEnabled(true);
                        loopersActivity.mStart.setBackgroundColor(Color.parseColor("#f97e7e"));
                    }
                    TOTAL_TIME_SEC--;
                    break;
            }
        }
    }

handler&postDelayed()

这个算是比较传统的定时方式了，发送指定延时的消息来达到定时周期执行的目的。

    /**
     * handler_postDelayed 方法实现
     */
    private Runnable mRunnable = new Runnable() {
        @Override
        public void run() {
            Message msg = mHandler.obtainMessage(2);
            mHandler.sendMessage(msg);
        }

    };
    // handler+postDelayed 方式，反复发送延时消息
    private void handlerPostDelayed() {
        mHandler.postDelayed(mRunnable, ONECE_TIME);
    }

Timer&TimerTask

通过 timer 执行周期延时的任务，handler 中将计时信息更新，并在计时结束时结束 timer 的周期任务

    /**
     * TimkerTask 方式实现
     */
    private Timer timer;

    private void timerTask() {
        timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                Message message = mHandler.obtainMessage(1);
                mHandler.sendMessage(message);
            }
        };
        timer.schedule(task, 0, ONECE_TIME);
    }

ScheduledExecutorService

此方式中 handler 功能与 timer 方式一致

    /**
     * ScheduledExecutorService 方式实现
     */
    private ScheduledExecutorService scheduled;

    private void scheduledExecutorService() {
        //初始化一个线程池大小为 1 的 ScheduledExecutorService
        scheduled = new ScheduledThreadPoolExecutor(1);
        mStart.setEnabled(false);//在发送数据的时候设置为不能点击
        mStart.setBackgroundColor(Color.GRAY);//背景色设为灰色
        scheduled.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Message msg = mHandler.obtainMessage(0);
                mHandler.sendMessage(msg);
            }
        }, 0, ONECE_TIME, TimeUnit.MILLISECONDS);
    }

RxJava

此方法通过 RxJava 的 interval 操作符来实现延时发送消息。接受消息的观察者将计时信息更新到 textview 中。此方法主要涉及到一些 RxJava 操作符以及线程切换，代码中也进行了注释。

/**
     * RxJava 方式实现
     */
    private void rxJava() {
        final long count = TOTAL_TIME / 1000;
        Observable.interval(0, 1, TimeUnit.SECONDS)//设置0延迟，每隔一秒发送一条数据
                .take((int) (count + 1)) //设置总共发送的次数
                .map(new Func1<Long, Long>() {//long 值是从小到大，倒计时需要将值倒置
                    @Override
                    public Long call(Long aLong) {
                        return count - aLong; 
                    }
                })
                .subscribeOn(Schedulers.computation())
                // doOnSubscribe 执行线程由下游逻辑最近的 subscribeOn() 控制，下游没有 subscribeOn() 则跟Subscriber 在同一线程执行
                //执行计时任务前先将 button 设置为不可点击
                .doOnSubscribe(new Action0() { 
                    @Override
                    public void call() { 
                        mStart.setEnabled(false);//在发送数据的时候设置为不能点击
                        mStart.setBackgroundColor(Color.GRAY);//背景色设为灰色
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())//操作UI主要在UI线程
                .subscribe(new Subscriber<Long>() {
                    @Override
                    public void onCompleted() {
                        mTvValue.setText(getResources().getString(R.string.done));
                        mStart.setEnabled(true);
                        mStart.setBackgroundColor(Color.parseColor("#f97e7e"));
                    }

                    @Override
                    public void onError(Throwable e) {
                        e.printStackTrace();
                    }

                    @Override
                    public void onNext(Long aLong) { //接收到一条就是会操作一次UI
                        String value = String.valueOf(aLong);
                        mTvValue.setText(value);
                    }
                });
    }

CountDownTimer

这货应该是实现倒计时功能最简单的方式了，直接使用 Android SDK 中的 CountDownTimer 类

/**
     * CountDownTimer 实现倒计时
     */
    private CountDownTimer countDownTimer = new CountDownTimer(TOTAL_TIME, ONECE_TIME) {
        @Override
        public void onTick(long millisUntilFinished) {
            String value = String.valueOf((int) (millisUntilFinished / 1000));
            mTvValue.setText(value);
        }

        @Override
        public void onFinish() {
            mTvValue.setText(getResources().getString(R.string.done));
        }
    };

     //调用 CountDownTimer 对象的 start() 方法开始倒计时，也不涉及到线程处理
     countDownTimer.start();

最后

以上五种倒计时(定时周期任务)方式就介绍完了，需要源码可以去 MvpDemo 中查看，本 Demo 持续更新欢迎 star
觉得本文对你有帮助
简书PandaQ404
掘金PandaQ
GithubPandaQAQ

Android 倒计时的五种实现方式