如何取消Android / Java线程中的长时间操作？

Question

While the following code is executing, I want the ability to stop it from running, even if it's halfway done. For example, if I have a boolean x = true; then I want to send some king of stop(ReadJSONFeedMainTask); command to this thread/class. I want to cancel everything, even what may be occurring in onPostExecute() . How can I do this?

Here is my code:

private void doStuff() {
    new ReadJSONFeedMainTask().execute(urlString);
}

private class ReadJSONFeedMainTask extends AsyncTask<String, Void, String> {
    protected String doInBackground(String... urls) {
        return Helper.readJSONFeed(urls[0]);
    }

    protected void onPostExecute(String result) {

        try {      
            dictItems = new ArrayList<HashMap<?, ?>>();
            JSONArray jsonArray = new JSONArray(result);
            Log.i("JSON", "Number of items in feed: " + jsonArray.length());

            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);

                HashMap<String, String> map = new HashMap<String, String>();

                Iterator<?> it = jsonObject.keys();
                while (it.hasNext())
                {
                      // do a bunch of time consuming stuff
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }  
    }
}

Answer 1

To cancel the task, do asyncTaskVariable.cancel(). If it's already in onPostExecute it's going to have to finish it though- you're on the UI thread and can't kill it. Best you can do there is set a variable that tells it to terminate (from another thread of course), and have it check that variable periodically, returning if its set.

Answer 2

Just skip out when x is true

 while (it.hasNext() && x == false) // where x is your skip boolean
 {
      // do a bunch of time consuming stuff
 }

and do similar in any other methods you want to terminate.

Its much safer than terminating it mid flow, as this can cause unusual behaviour.

Answer 3

You should call

asyncTaskVariable.cancel( true );

this will force the asynctask to stop.

BUT, you should know that is won't stop immediatly.

If the thread is waiting for IO input, it will be in the "blocked io state". Then it won't be stopped. If you don't have control over what happens in this Helper method, you can't change anything. But if you own it, then you can loop through the input stream and read it by a number of bytes each time (using a buffer). This will give you opportunities to stop your threead. For that do something like

int readBytes = 0;
while( readBytes != -1 && !Thread.interrupted ) {
   readBytes = bufferedReader.read( buffer );
   if( readBytes >0 ) { 
      stringBuilder.append( buffer, 0, readBytes ); 
   }
}

using the interrupted flag, you will be able to stop your thread when your asynctask is cancelled.

You should consider not using an AsyncTask for your network operations. They have been designed for short living tasks.

AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework. AsyncTasks should ideally be used for short operations (a few seconds at the most.) If you need to keep threads running for long periods of time, it is highly recommended you use the various APIs provided by the java.util.concurrent pacakge such as Executor, ThreadPoolExecutor and FutureTask.

An alternative is to use an Android Service, like with the RoboSpice library.

Answer 4

You need to keep a reference to your class in order to do that. For example...

private ReadJSONFeedMainTask foo;

private void doStuff() {
    foo = new ReadJSONFeedMainTask();
    foo.execute(urlString);
}

Then later on when you have an interrupt event you can just call

foo.cancel(true);

The true parameter indicates an immediate interrupt.

EDIT I didnt notice your placement of the longrunning task in the postexecute. As gabe mentioned correctly, even cancel() will not help you there. You will need to refactor your code to put the longrunning task in the doInBackground method so that it is immediately cancelable, in addition to holding a reference to it as above.