如何从处理程序中删除所有回调？

Question

我的子活动中有一个由主活动调用的 Handler 活动。此处理程序由子类使用 postDelay 一些 Runnables，我无法管理它们。现在，在 onStop 事件中，我需要在完成 Activity 之前删除它们（不知何故我调用了 finish()，但它仍然一次又一次地调用）。是否有办法从处理程序中删除所有回调？

Answer 1

根据我的经验，这非常有效！

handler.removeCallbacksAndMessages(null);

在removeCallbacksAndMessages的文档中它说......

删除任何 obj 为 token 的待处理回调帖子和已发送消息。 如果令牌为null，则所有回调和消息都将被删除。

Answer 2

对于任何特定的 Runnable 实例，调用 Handler.removeCallbacks()。请注意，它使用 Runnable 实例本身来确定要取消注册的回调，因此，如果您每次发布帖子时都创建一个新实例，则需要确保引用了确切的 Runnable 取消。示例：

Handler myHandler = new Handler();
Runnable myRunnable = new Runnable() {
    public void run() {
        //Some interesting task
    }
};

您可以调用 myHandler.postDelayed(myRunnable, x) 来将另一个回调发送到代码中其他位置的消息队列，并使用 myHandler.removeCallbacks(myRunnable) 删除所有挂起的回调 不幸的是

，即使您向 MessageQueue 对象发出请求，您也不能简单地“清除”Handler 的整个 MessageQueue与它关联是因为添加和删除项目的方法受包保护（只有 android.os 包中的类可以调用它们）。您可能需要创建一个精简的 Handler 子类来管理发布/执行的 Runnable 列表...或者查看另一种范例，用于在每个 Runnable 之间传递消息活动

希望有帮助！

Answer 3

定义一个新的处理程序并可运行：

private Handler handler = new Handler(Looper.getMainLooper());
private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            // Do what ever you want
        }
    };

延迟调用后：

handler.postDelayed(runnable, sleep_time);

从处理程序中删除回调：

handler.removeCallbacks(runnable);

Answer 4

请注意，应该在类作用域中定义一个 Handler 和一个 Runnable，以便它被创建一次。removeCallbacks(Runnable) 可以正常工作，除非人们多次定义它们。请查看以下示例以更好地理解：

不正确的方式：

    public class FooActivity extends Activity {
           private void handleSomething(){
                Handler handler = new Handler();
                Runnable runnable = new Runnable() {
                   @Override
                   public void run() {
                      doIt();
                  }
               };
              if(shouldIDoIt){
                  //doIt() works after 3 seconds.
                  handler.postDelayed(runnable, 3000);
              } else {
                  handler.removeCallbacks(runnable);
              }
           }

          public void onClick(View v){
              handleSomething();
          }
    } 

如果您调用 onClick(..) 方法，则在调用之前永远不会停止 doIt() 方法的调用。因为每次都会创建新的 Handler 和新的 Runnable 实例。这样，您就丢失了属于 handler 和 runnable 实例的必要引用。

正确的方法：

 public class FooActivity extends Activity {
        Handler handler = new Handler();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                doIt();
            }
        };
        private void handleSomething(){
            if(shouldIDoIt){
                //doIt() works after 3 seconds.
                handler.postDelayed(runnable, 3000);
            } else {
                handler.removeCallbacks(runnable);
            }
       }

       public void onClick(View v){
           handleSomething();
       }
 } 

通过这种方式，您不会丢失实际引用，并且 removeCallbacks(runnable) 可以成功工作。

关键句子是“在您使用的Activity或Fragment中将它们定义为全局”。

Answer 5

如果您没有 Runnable 引用，则在第一个回调中获取消息的 obj，然后使用 removeCallbacksAndMessages() 删除所有相关回调。

Answer 6

正如josh527所说，handler.removeCallbacksAndMessages(null);可以工作。
但为什么呢？
如果你看一下源代码，你会更清楚地理解。
有 3 种类型的方法可以从处理程序（MessageQueue）中删除回调/消息：

1. 通过回调（和令牌）删除
2. 通过消息删除（和令牌）
3. 通过令牌删除

Handler.java（保留一些重载方法）

/**
 * Remove any pending posts of Runnable <var>r</var> with Object
 * <var>token</var> that are in the message queue.  If <var>token</var> is null,
 * all callbacks will be removed.
 */
public final void removeCallbacks(Runnable r, Object token)
{
    mQueue.removeMessages(this, r, token);
}

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

/**
 * Remove any pending posts of callbacks and sent messages whose
 * <var>obj</var> is <var>token</var>.  If <var>token</var> is null,
 * all callbacks and messages will be removed.
 */
public final void removeCallbacksAndMessages(Object token) {
    mQueue.removeCallbacksAndMessages(this, token);
}

MessageQueue.java do真正的工作：

void removeMessages(Handler h, int what, Object object) {
    if (h == null) {
        return;
    }

    synchronized (this) {
        Message p = mMessages;

        // Remove all messages at front.
        while (p != null && p.target == h && p.what == what
               && (object == null || p.obj == object)) {
            Message n = p.next;
            mMessages = n;
            p.recycleUnchecked();
            p = n;
        }

        // Remove all messages after front.
        while (p != null) {
            Message n = p.next;
            if (n != null) {
                if (n.target == h && n.what == what
                    && (object == null || n.obj == object)) {
                    Message nn = n.next;
                    n.recycleUnchecked();
                    p.next = nn;
                    continue;
                }
            }
            p = n;
        }
    }
}

void removeMessages(Handler h, Runnable r, Object object) {
    if (h == null || r == null) {
        return;
    }

    synchronized (this) {
        Message p = mMessages;

        // Remove all messages at front.
        while (p != null && p.target == h && p.callback == r
               && (object == null || p.obj == object)) {
            Message n = p.next;
            mMessages = n;
            p.recycleUnchecked();
            p = n;
        }

        // Remove all messages after front.
        while (p != null) {
            Message n = p.next;
            if (n != null) {
                if (n.target == h && n.callback == r
                    && (object == null || n.obj == object)) {
                    Message nn = n.next;
                    n.recycleUnchecked();
                    p.next = nn;
                    continue;
                }
            }
            p = n;
        }
    }
}

void removeCallbacksAndMessages(Handler h, Object object) {
    if (h == null) {
        return;
    }

    synchronized (this) {
        Message p = mMessages;

        // Remove all messages at front.
        while (p != null && p.target == h
                && (object == null || p.obj == object)) {
            Message n = p.next;
            mMessages = n;
            p.recycleUnchecked();
            p = n;
        }

        // Remove all messages after front.
        while (p != null) {
            Message n = p.next;
            if (n != null) {
                if (n.target == h && (object == null || n.obj == object)) {
                    Message nn = n.next;
                    n.recycleUnchecked();
                    p.next = nn;
                    continue;
                }
            }
            p = n;
        }
    }
}

Answer 7

这些解决方案都不适合我。但我找到了一个有效的解决方案。

即使在调用handler.removeCallbacksAndMessages(null)之后，已添加到处理程序队列中的可运行对象也会被执行。当我尝试停止线程时，导致错误：

W/MessageQueue(6436): java.lang.RuntimeException: Handler (android.os.Handler) {416659f0} sending message to a Handler on死线程

我的解决方案：

• 删除所有回调。你需要所有的参考
  可以存储在 ArrayList 中的可运行对象。

   private ArrayList; runnableQueue=new ArrayList();
  

• 然后每次你想发布一个可运行的文件时，将其存储在数组中，然后使用 handler.post() 发布数组项。

  private void postInHandler(){
    @覆盖
    runnableQueue.add(new Runnable() {
        公共无效运行（）{   
            //你的代码 
        }
    });
    //发布数组中的最后一项 
    handler.post(runnableQueue.get(runnableQueue.size()-1));
    }
  

• 然后要删除所有回调，请使用此方法，该方法将通过迭代数组来删除每个回调。

   private void removeHandlerCallbacks(){
       for（可运行可运行：可运行队列）{
           networkHandler.removeCallbacks(runnable,null);
       }
       runnableQueue.clear();
   }
  

• 万岁！队列被清除。 但是等等。清除数组后，我们必须确保在停止线程之前，处理程序中不再发布可运行的内容。所以你必须声明：

  布尔值allowPosting=true;

因此包括以下内容：

private void removeHandlerCallbacks(){           
    allowPosting=false;//add this line to stop posting after clearing the array
    for(Runnable runnable:runnableQueue){
        handler.removeCallbacks(runnable,null);
    }
     //Dont forget to clear the array
     runnableQueue.clear();
}

然后在处理程序中发布之前检查条件：

if(allowPosting){
    postInHandler();
}

就这样，现在队列已清除，我们确信不再发布可运行的内容清除队列后。所以停止线程是安全的。

Answer 8

文档说 removeCallbacksAndMessages(null) 删除所有回调，但并不总是如此。试试这个：

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
    handler.removeCallbacksAndMessages("ACTION_NAME")
    handler.postDelayed(runnable, "ACTION_NAME", 10_000) //if you want restart runnable
} else {
    handler.removeCallbacksAndMessages(null)
    handler.postDelayed(runnable, 10_000) //if you want restart runnable
}

Answer 9

删除特定可运行对象

handler.removeCallbacks(yourRunnable)

删除所有可运行对象

handler.removeCallbacksAndMessages(null)