有点意思的定时器 CountDownTimer

背景

这是个抽象类，我以为这个定时器实现有点简单，可是具备不稳定性，也就有点意思；也许你对它的实现会感兴趣，请跟我来

成员变量

private final long mMillisInFuture;

    private final long mCountdownInterval;

    private long mStopTimeInFuture;

    private boolean mCancelled = false;
复制代码

执行总时长，执行间隔，中止时间，可取消； 执行总时长，执行间隔，经过构造器传入

核心成员变量

private Handler mHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {

            synchronized (CountDownTimer.this) {
                if (mCancelled) {
                    return;
                }

                final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();

                if (millisLeft <= 0) {
                    onFinish();
                } else {
                    long lastTickStart = SystemClock.elapsedRealtime();
                    onTick(millisLeft);

                    long lastTickDuration = SystemClock.elapsedRealtime() - lastTickStart;
                    long delay;

                    if (millisLeft < mCountdownInterval) {

                        delay = millisLeft - lastTickDuration;

                        if (delay < 0) delay = 0;
                    } else {
                        delay = mCountdownInterval - lastTickDuration;

                        while (delay < 0) delay += mCountdownInterval;
                    }

                    sendMessageDelayed(obtainMessage(MSG), delay);
                }
            }
        }
    };
复制代码

1. 利用了handler消息机制；可是handler，其执行线程，为初始化所处线程；若是不是主线程，须要本身启用looper
2. 到达结束时间，则调用onFinish方法，结束
3. 上次任务onTick执行时间，暂用总共可执行时间
4. 两次重复执行主体时间间隔为预期时间的倍数

抽象方法

public abstract void onTick(long millisUntilFinished);
    public abstract void onFinish();
复制代码

定时结束、每次任务执行

取消与执行

public synchronized final void cancel() {
        mCancelled = true;
        mHandler.removeMessages(MSG);
    }

    public synchronized final CountDownTimer start() {
        mCancelled = false;
        if (mMillisInFuture <= 0) {
            onFinish();
            return this;
        }
        mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
        mHandler.sendMessage(mHandler.obtainMessage(MSG));
        return this;
    }
复制代码

经过消息机制取消；经过消息机制进行定时执行

总结

1. 一个使用比较轻松的定时器，主线程中不须要作多余的管理操做；
2. 在规定时间内，能够间隔执行任务的定时器
3. 执行次数不肯定的定时器
4. 首次不能延时执行

这样的定时器，被使用场景裹住了脚，用起来贼有意思

技术变化都很快，但基础技术、理论知识永远都是那些；做者但愿在余后的生活中，对经常使用技术点进行基础知识分享；若是你以为文章写的不错，请给与关注和点赞；若是文章存在错误，也请多多指教！