removeCallbacks not stopping runnable

I am calling from a method:

myHandler.postDelayed(mMyRunnableHide, 6000);


which calls:

public Runnable mMyRunnableHide = new Runnable()
{

public void run()
{
mTextDisplay.setText("");
DisplayX();
}
};


if a button on screen is clicked I want to stop the runnable:

Button next = (Button) findViewById(R.id.Breaction);
next.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {

myHandler.removeCallbacks(mMyRunnableHide);

mTextDisplay.setText("");
DisplayX();
}
});
}


the removecallbacks is not stopping the runnable. What am I doing wrong? Am I using the correct method? I just want the runnable to "Not Run" when the user clicks the button.

Thanks for any help.

@YekmerSimsek Runnable class has no stop() method.
– joao2fast4u
Oct 24 '14 at 14:43

4 Answers
4

It appears to me that removeCallbacks(..) only stops pending messages (Runnables). If your runnable has already started, then there's no stopping it (at least not this way).

removeCallbacks(..)

Alternatively, you can extend the Runnable class and give it some kind of kill switch like this:

public class MyRunnable implements Runnable
{
private boolean killMe = false;

private void run()
{
if(killMe)
return;

/* do your work */
}

private void killRunnable()
{
killMe = true;
}
}


This will only prevent it from starting, but you could occasionally check killMe and bail out. If you are looping the runnable (like some kind of background thread) you can say:

killMe

while(!killMe) {
/* do work */
}


Hope this helps

EDIT I just wanted to post an update on this. Since this original post, Google has come up with a great class called AsyncTask that handles all of this stuff for you. Anyone reading this really should look into it because it is the correct way of doing things.

You can read about it here

Be sure to mark killMe as volatile. Otherwise, the compiler is likely to replace while(!killMe) with while(true), since it never changes (as far as it can tell).
– Andy Shulman
May 1 '11 at 3:02

volatile

while(!killMe)

while(true)

typo, MyRunnable "implements" Runnable {...} not "extends"
– Palani
Oct 11 '11 at 4:47

@AndyShulman volatile variables are most useful when you have many threads accessing the same global variable. What volatile is actually saying is, "Never store this variable in a register. Always read it from memory". This becomes important if you have code where a variable is frequently read/changed and must remain accurate across threads.
– mtmurdock
Apr 15 '12 at 18:52

@AndyShulman you're wrong. Neither javac nor the java/dalvik vm will do what you claim it will.
– dcow
Oct 15 '13 at 18:46

@mtmurdock removeCallbacks is synchronous and takes effect immediately when called from the main thread. There ican be no "already started" callback running concurrently in the main thread. If a Runnable were running then the button handler could never run until the Runnable finishes. If everything is called from the main thread flags are not needed.
– Mister Smith
Mar 15 '16 at 16:12

removeCallbacks

Handler.removeCallback is synchronous and will work nicely provided:

Handler.removeCallback

postDelayed

removeCallback

postDelayed

So in your case removeCallbacks is called from a button handler, which runs in the main thread. But you didn't show in your code the point from where you call postDelayed. If you call it from a background thread thats where your problem is.

removeCallbacks

postDelayed

If you are sure you don't call any of these methods from background threads, and the order of the calls is correct, then you might be leaving uncancelled tasks unadvertedly alive due to activity recreation on config changes (screen rotation, etc). Always make sure to call removeCallbacks again in the onDestroy method to prevent this kind of problems.

removeCallbacks

onDestroy

Here is another way to accomplish what mtmurdock is describing. This class will allow editing of instance variables in any class that your Runnable is defined as an anonymous inner class.

package support;

/**
* Runnable that can be stopped from executing
* @author JTRONLABS
*/
public abstract class KillableRunnable implements Runnable{

private boolean isKilled=false;

/**
* Instead of Overriding run(), override this method to perform a Runnable operation.
* This will allow editing instance variables in the class that this Runnable is defined
*/
public abstract void doWork();

//The handler that posts this Runnable will call this method.
//By default, check if it has been killed. doWork() will now be the method
//override to implement this Runnable
@Override
final public void run(){
if(!isKilled){
doWork();
}
}

final public void kill(){
isKilled=true;
}
}


I don't think that removeCallbacks(..) only stops pending messages (Runnables) ，I think removeCallbacks(..) not working have other cause,but i don‘t know. because postDelayed(..) and removeCallbacks(..) is in the same thread

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.