AsyncTask will always run even if app is destroyed?

I have an application and because you can't do network operations on the main thread I'm using AsyncTask, so the question is once I execute() the AsyncTask and right after that I finish() the activity, and maybe the user will finish() the whole app, so what I'm wondering is:

Will AsyncTask always finish doInBackground() and onPostExecute() even if the app is closed as long as execute() was called when the app was running?

wtsang02

You will be able to test this. And yes It does. If execute was called you can see Asynctask will still execute UNLESS it does something to the forground or UI related. (it may cause launcher to crash).

However, if it was close by the system. It may or may not continue executing the method. I have already tested and answered here. Reply to comment: Tested:

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Worker().execute();
    }
private class Worker extends AsyncTask<Void, Void, String> {

    @Override
    protected String doInBackground(Void... arg0) {
        Log.i("SomeTag",
                "start do in background at " + System.currentTimeMillis());
        String data = null;

        try {
            DefaultHttpClient httpClient = new DefaultHttpClient();
            HttpGet httpGet = new HttpGet(
                    "https://stackoverflow.com/questions/tagged/android");

            HttpResponse httpResponse = httpClient.execute(httpGet);
            HttpEntity httpEntity = httpResponse.getEntity();
            data = EntityUtils.toString(httpEntity);
            Log.i("SomeTag",
                    "doInBackGround done at " + System.currentTimeMillis());
        } catch (Exception e) {
        }
        return data;
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        Log.i("SomeTag", System.currentTimeMillis() / 1000L
                + " post execute \n" + result);
    }
}

@Override
protected void onDestroy() {
    super.onDestroy();
    Log.i("SomeTag", System.currentTimeMillis() / 1000L + "  onDestory()");
}

04-24 21:42:57.981: I/SomeTag(5961): start do in background at 1366854177994
04-24 21:43:00.974: I/SomeTag(5961): 1366854180  onDestory()
04-24 21:43:02.946: I/SomeTag(5961): doInBackGround done at 1366854182946
04-24 21:43:02.946: I/SomeTag(5961): 1366854182 post execute 
04-24 21:43:02.946: I/SomeTag(5961): <!DOCTYPE html>
04-24 21:43:02.946: I/SomeTag(5961): <html>
04-24 21:43:02.946: I/SomeTag(5961): <head>
04-24 21:43:02.946: I/SomeTag(5961):         
04-24 21:43:02.946: I/SomeTag(5961):     <title>Newest &#39;android&#39; Questions - Stack Overflow</title>
04-24 21:43:02.946: I/SomeTag(5961):     <link rel="shortcut icon" href="http://cdn.sstatic.net/stackoverflow/img/favicon.ico">
//....

onPostExecute() is called from the UI thread - so if the UI thread is no longer running, it will not continue to run. However doInBackGround() is ran from a separate worker thread so it will keep on until done (or if the JVM process is killed by the OS, which is also a possibility). Note that AsyncTasks are only recommended for shorter UI-bound background tasks and not long-running background work (a few seconds).

In short, you can not assume that it will keep on and definitely not assume that it will post its progress or call onPostExecute().

When you call finish() on Activity, the Activity is destroyed, but the main thread is not. [NOTE: Activity runs on Main Thread. Activity is not Main Thread. ]

So, doInBackground() on background thread and onPostExecute() on main thread will be executed. However, if onPostExecute() does any UI-related tasks, you will get ANR because there is no UI at this point. For eg, if you just print a Log.d() statement inside onPostExecute(), the statement will be visible in Logcat.

** These will be possible only if the process is alive, & is not killed by Android Low Memory Killer.

See the image to see which methods are executed in which thread.

You can easily test this, just make doInBackground() last longer, for example add Thread.sleep(5000) and then try various scenarios :

If you finish the Activity that started the AsyncTask, or navigate away from it, AsyncTask finishes normaly, but then you'll probably cause a memory leak or crash your app in onPostExecute() if you hold a reference to the surrounding Activity (like a UI element), that is not "alive" any more.
If you minimize your app by pressing "home" button, it will again complete normally, but can crash the app in onPostExecute()
If you kill your app process (or the system does that), it will terminate your AsyncTask and the job you wanted it to do doInBackground() will not be done. The same goes if you simply start the thread using new Thread(new Runnable() {...

来源：https://stackoverflow.com/questions/16204693/asynctask-will-always-run-even-if-app-is-destroyed

标签

android

android-asynctask

android-lifecycle