Android 延时操作笔记

• Thread
• Handler
• TimerTask
• RxJava
• 封装

很基础的东西，研究了一下不同的实现的方法，都大同小异，记录一下。
目标是延迟一段时间之后在主线程执行操作。

几个方法都是靠 Handler 接受子线程发来的 msg 来实现线程的切换的效果，不同的是用什么方法来开启一个新线程来达到延时发送 msg。

下面是接受到消息的 Handler:
要注意的是 Handler 在 new 的时候和当前环境中的线程绑定，所以要保证在主线程中创建该对象。

private Handler mHandler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what){
            case 1:
            // 在主线程中
            break;
        }
    }
};

Thread

调用 Thread.sleep() 实现延时。

new Thread(new Runnable() {
    @Override
    public void run() {
        Thread.sleep(delayTime);
        mHandler.sendMessage();
    }
}).start();

Handler

postDelayed() 第二个参数传入延时时间。

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        mHandler .sendEmptyMessage(1);
    }
},delayTime);

TimerTask

TimerTask 结合 Timer 实现延时操作。

TimerTask task = new TimerTask(){
    public void run(){
        mHandler .sendEmptyMessage(1);
    }
};
Timer timer = new Timer();
timer.schedule(task, delayTime);

RxJava

这种方法虽然不用借助 Handler，但是看起来太长了，和其他的方法也没有太多区别。
重点是delay(1, TimeUnit.SECONDS) 将事件流的发送延迟了 1 秒，
而 observeOn(AndroidSchedulers.mainThread()) 将后续的线程切换到了主线程。

Observable.fromArray("a")
        .subscribeOn(Schedulers.io())
        .delay(1, TimeUnit.SECONDS)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String value) {
               // do something
            }

            @Override
            public void onError(Throwable e) {
 
            }

            @Override
            public void onComplete() {
                //do something
            }
        });

封装成一个类

用于仅仅需要延迟执行一些简单操作,封装成一个工具类：

先看使用：

new TimeUtil(1, TimeUnit.SECONDS).setTodo(new TimeUtil.Todo() {
    @Override
    public void something() {
        //在主线程中执行
       boolean isMain = Looper.myLooper() == Looper.getMainLooper();
       Log.d(TAG, "isMain :" + isMain);
    }
});

输出为 true，确实在主线程中执行。
至于实现很简单，不赘述：

public class TimeUtil {

    private Todo todo;

    public TimeUtil(int delatTime,TimeUnit timeType){
        //第一个参数是延迟的时间，第二个参数是时间的单位
        delayTimeToDo(delatTime,timeType);
    }

    public void setTodo(Todo d){
        todo = d;
    }

    public static interface Todo{
        public void something();//调用时实现改方法
    }

    private void delayTimeToDo(int dalayTime,TimeUnit type){
        //用 RxJava 比较省力，用上述其他的方法是一样的
        Observable.fromArray("a")
                .subscribeOn(Schedulers.io())
                .delay(dalayTime,type)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String value) {
                        // do something
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        if (todo != null){
                            todo.something();
                        }
                    }
                });
    }
}