Android(安卓)Handler.removeMessage移除所有postDelayed的问题

Android Handler.removeMessage暗坑

在Android开发中，Handler的使用应该是比较多的，可以用它在UI线程中进行操作，也可以很方便的使用delay延时动作。

Handler的延时操作分两种:

1.延时执行一个可运行任务

Handler.postDelayed(runnable, 10000)

2.延时发送一条Message消息

Handler.sendEmptyMessageDelayed(0, 10000)

今天开发中遇到一个诡异的问题，handler.removeMessage(0)把所有的延时执行可运行任务都移除掉了，按照这个api的注释来看，应该是移除指定msg.what的延时消息才对。为什么会把其他的可执行任务都移除掉了?

接下来我们来创建一个自定义Handler

class MyHandler extends Handler{    @Override    public void handleMessage(Message msg) {        super.handleMessage(msg);        Log.d(TAG, "handleMessage: "+msg.what);    }}

然后再创建两个自定义Runnable

Runnable runnable1 = new Runnable() {    @Override    public void run() {        Log.d(TAG, "run: 1");    }};Runnable runnable2 = new Runnable() {    @Override    public void run() {        Log.d(TAG, "run: 2");    }};

然后开始执行handler的操作

MyHandler handler = new MyHandler();handler.postDelayed(runnable1,2000);handler.postDelayed(runnable2,2000);handler.sendEmptyMessageDelayed(0,2000);handler.sendEmptyMessageDelayed(1,2000);handler.sendEmptyMessageDelayed(2,2000);handler.removeMessages(0);

最后看一下打印出来的log

D/MainActivity: handleMessage: 1D/MainActivity: handleMessage: 2

可以看到只有1和2两条延时发送的Message打印出来了，另外3个延时操作全部被取消掉，这里面果然有坑

那只有看看源码到底是怎么回事了

/** * Remove any pending posts of messages with code 'what' that are in the * message queue. */public final void removeMessages(int what) {    mQueue.removeMessages(this, what, null);}/** * Remove any pending posts of messages with code 'what' and whose obj is * 'object' that are in the message queue.  If object is null, * all messages will be removed. */public final void removeMessages(int what, Object object) {    mQueue.removeMessages(this, what, object);}

看到源码中实际调用了api的mQueue.removeMessages,并且注释中解释了参数的作用，移除指定msg.what的消息，如果指定了object对象并且该object存在消息队列中则只移除该object。如果object是null，则移除消息队列中所有msg.what等于what参数的消息。

看这段api的注释，好像并没有什么问题，继续查找Handler.postDelayed的源码

/** * Causes the Runnable r to be added to the message queue, to be run * after the specified amount of time elapses. * The runnable will be run on the thread to which this handler * is attached. * The time-base is {@link android.os.SystemClock#uptimeMillis}. * Time spent in deep sleep will add an additional delay to execution. *   * @param r The Runnable that will be executed. * @param delayMillis The delay (in milliseconds) until the Runnable *        will be executed. *         * @return Returns true if the Runnable was successfully placed in to the  *         message queue.  Returns false on failure, usually because the *         looper processing the message queue is exiting.  Note that a *         result of true does not mean the Runnable will be processed -- *         if the looper is quit before the delivery time of the message *         occurs then the message will be dropped. */public final boolean postDelayed(Runnable r, long delayMillis){    return sendMessageDelayed(getPostMessage(r), delayMillis);}/** * Enqueue a message into the message queue after all pending messages * before (current time + delayMillis). You will receive it in * {@link #handleMessage}, in the thread attached to this handler. *   * @return Returns true if the message was successfully placed in to the  *         message queue.  Returns false on failure, usually because the *         looper processing the message queue is exiting.  Note that a *         result of true does not mean the message will be processed -- if *         the looper is quit before the delivery time of the message *         occurs then the message will be dropped. */public final boolean sendMessageDelayed(Message msg, long delayMillis){    if (delayMillis < 0) {        delayMillis = 0;    }    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);}

可以看到postDelayed内部调用了sendMessageDelayed方法！也就是说postDelayed的本质也是使Handler发送Message消息。而Message对象的创建则在getPostMessage(r)方法中。继续往下看

private static Message getPostMessage(Runnable r) {    Message m = Message.obtain();    m.callback = r;    return m;}

public final class Message implements Parcelable {    public int what;    ...    /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).    */    public Message() {    }    ...    /**     * Return a new Message instance from the global pool. Allows us to     * avoid allocating new objects in many cases.     */    public static Message obtain() {        synchronized (sPoolSync) {            if (sPool != null) {                Message m = sPool;                sPool = m.next;                m.next = null;                m.flags = 0; // clear in-use flag                sPoolSize--;                return m;            }        }        return new Message();    }}

getPostMessage方法通过Message.obtain()获得了一个Message对象，并且把可运行任务绑定到message.callback中。通过上面Message源码注释可以了解,obtain()会从Message池中返回一个新的Message对象，再看Message的构造方法，空空如也。

所以问题找到了，一个新的Message对象，它的what变量默认为0！
这就解释了为什么handler.removeMessage(0)会把所有可执行任务都移除掉。

避开removeMessage暗坑方法:
1.自定义handler处理的msg.what消息不要使用默认值0
2.同一个handler不要同时使用postDelayed()和postMessageDelayed()两个方法

Android Handler.removeMessage暗坑

更多相关文章

随机推荐