When to use AsyncTask and When to use Thread in Android

Question

When to use AsyncTask and When to use Thread as both do work in background and both can manipulate controls in UI Thread by some mecha

Answer 1

AsyncTask is just a "helper" class provided with Android SDK to make it easier to skip to the UI thread after the background task is finished. It is built over the standard Java threading API. It does not give antyhing that cannot be done with Threads only. It addresses the common scenario of switching between the short task run background thread and UI thread.

Generally it is convenient to use AsyncTask when you must "skip back" to UI thread when the background task is done or when you have to give some feedback to UI thread during task execution. Otherwise it's just overhead.

You are not forced to use AsyncTask. If you as a developer prefer using Threads directly or Futures you may use it and skip to UI thread on your own manually after the background task is done.

EDIT:

Some other answers here suggest that using AsyncTask should be limited to short tasks. Allegedly because it uses a common pool. However it is no longer true since API Level 11 (so, for quite a long time). You can use executeOnExecutor instead of execute to execute AsyncTask's in dedicated thread pool. See http://developer.android.com/reference/android/os/AsyncTask.html#executeOnExecutor%28java.util.concurrent.Executor,%20Params...%29

Because examples are usually more communicative look at the example below.

Let's assume that we have a static function to do some heavy task and a TextView which we want to display progress and final status of the task declared as below:

static Object doHeavyTask(String string) throws Exception;

TextView progressInfo;

Execution of the task in background thread using async task would look like:

new AsyncTask() {

    @Override
    protected Exception doInBackground(String... params) {
        for (int i = 0; i < params.length; i++) {
            try {
                doHeavyTask(params[i]);
            } catch (Exception e) {
                return e;
            }
            publishProgress(i, params.length);
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        progressInfo.setText("Executed " + values[0] + 
            " of " + values[1] + " tasks.");
    }

    @Override
    protected void onPostExecute(Exception result) {
        if (result == null) {
            progressInfo.setText("Heavy background job done successfully!");
        }
        else {
            progressInfo.setText("Heavy background job failed!" + 
                "Exception message: " + result.getMessage());
        }
    }
}.execute("input1", "input2", "input3");

Exactly the same can be achieved with Thread:

final Handler handler = new Handler(Looper.getMainLooper());
final String[] params = { "input1", "input2", "input3" };
new Thread() {

    @Override
    public void run() {
        for (int i = 0; i < params.length; i++) {
            try {
                doHeavyTask(params[i]);
            } catch (final Exception e) {
                handler.post(new Runnable() {

                    @Override
                    public void run() {
                        progressInfo.setText("Heavy background job failed!" +
                            "Exception message: " + e.getMessage());
                    }
                });
                return;
            }

            final int currentIndex = i;
            handler.post(new Runnable() {

                @Override
                public void run() {
                    progressInfo.setText("Executed " + currentIndex +
                            " of " + params.length + " tasks.");
                }
            });
        }

        handler.post(new Runnable() {

            @Override
            public void run() {
                progressInfo.setText(
                    "Heavy background job done successfully!");
            }
        });
    }
}.start();

As you see above using the AsyncTask is simply a bit more convenient. But there is no other advantage, just this convenience :). If you prepared your own task encapsulating Thread (and a Handler to skip back to the UI thread) then maybe your class will be more efficient/comfortable for you to use. That's all :).