今天完成的事情

执行定时周期性的任务的五种方式，包括但不限于实现倒计时功能。这五种方式分别是：

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

明天的计划

继续写页面