Android中优雅的线程切换写法（二）

 Android中优雅的线程切换写法（一），接上回继续写。在实现延迟执行任务之后，再实现移除延迟任务。这个就需要先做一个栈，把所有的延迟任务put到这个栈中，并以一个唯一tag作为标记。等到需要移除的时候，通过移除这个tag标记的Runnable就行了。

以上是实现的基本思路，那么具体做法如下：

1、首先对原有的ThreadUtil类进行修改，增加一个Map集合作为“任务栈”保存所有的延迟任务。

2、其次修改原来的handler对象实现方式，增加 DO_DELAYED_MAIN_THREAD、DO_DELAYED_CHILD_THREAD 两个case。用来执行具体的Runnable任务。执行完之后，将Runnable从Map中移除。

3、修改原有的runOnMainThreadDelayed、runOnChildThreadDelayed方法的返回值，让他们返回唯一的tag标识，这个标识将会用来移除延迟任务。

4、增加一个removeDelayedThread方法，用来根据唯一tag标识来移除延迟任务。

    private static final int DO_DELAYED_MAIN_THREAD = 2;
    private static final int DO_DELAYED_CHILD_THREAD = 3;

    //用于保存所有的延迟执行任务
    private static Map delayMap = new HashMap<>();


    @SuppressLint("HandlerLeak")
    private static Handler handler = new Handler() {
        @Override
        public void dispatchMessage(Message msg) {
            super.dispatchMessage(msg);
            switch (msg.what) {
                case DelayedRunChildThread:
                    runOnChildThread((Runnable) msg.obj);
                    break;
                case DO_DELAYED_MAIN_THREAD:
                    Runnable main = delayMap.get(msg.obj.toString());
                    if (main != null){
                        main.run();
                        //移除掉被执行的任务
                        delayMap.remove(msg.obj.toString());
                    }
                    break;
                case DO_DELAYED_CHILD_THREAD:
                    Runnable child = delayMap.get(msg.obj.toString());
                    if (child != null){
                        runOnChildThread(child);
                        //移除掉被执行的任务
                        delayMap.remove(msg.obj.toString());
                    }
                    break;
            }
        }
    };
    
    /**
     * 在主线程中延迟执行一个Runnable接口
     * @param time 延迟时间，以毫秒为单位
     * @return 每个延迟任务的唯一tag标记
     */
    public static String runOnMainThreadDelayed(Runnable runnable, long time) {
        if (runnable == null || time < 0) return "";
        //生成唯一的tag标识
        String tag = String.valueOf(runnable.hashCode() + System.currentTimeMillis());
        //将Runnable放到待执行的栈中
        delayMap.put(tag, runnable);
        Message message = Message.obtain();
        message.what = DO_DELAYED_MAIN_THREAD;
        message.obj = tag;
        handler.sendMessageDelayed(message, time);
        return tag;
    }
    
    /**
     * 延迟执行一个子线程
     * @param time 延迟时间，以毫秒为单位
     * @param return 每个延迟任务的唯一tag标记
     */
    public static String runOnChildThreadDelayed(Runnable runnable, long time) {
        if (runnable == null || time < 0) return "";
        //生成唯一的tag标识
        String tag = String.valueOf(runnable.hashCode() + System.currentTimeMillis());
        delayMap.put(tag, runnable);
        Message message = Message.obtain();
        message.what = DO_DELAYED_CHILD_THREAD;
        message.obj = tag;
        handler.sendMessageDelayed(message, time);
        return tag;
    }

    /**
     * 移除掉还没有执行的延迟任务
     * @param tag 每个延迟任务的唯一标识
     */
    public static void removeDelayedThread(String tag){
        delayMap.remove(tag);
    }