Difference Between Thread and AsyncTask in Android


What is the difference between Thread and AsyncTask? When to use Thread and when to use AsyncTask?
In any higher programming language, there is a concept of multi-tasking. Basically the user needs to run some portion of code without user interaction. A thread is generally developed for that. But in Android, multi-tasking can be done by any of the three methods Thread, Service and AsyncTask. I am currently giving you what is the difference between Thread and AsyncTask.


A thread is a concurrent unit of execution. It has its own call stack. There are two methods to implement threads in applications.
  1. One is providing a new class that extends Thread and overriding it's run() method.
  2. The other is providing a new Thread instance with a Runnable object during its creation.
A thread can be executed by calling its "start" method. You can set the "Priority" of a thread by calling its "setPriority(int)" method.
A thread can be used if you have no effect in the UI part. For example, you are calling some web service or download some data, and after download, you are displaying it to your screen. Then you need to use a Handler with a Thread and this will make your application complicated to handle all the responses from Threads.
A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each thread has each message queue. (Like a To do List), and the thread will take each message and process it until the message queue is empty. So, when the Handler communicates, it just gives a message to the caller thread and it will wait to process.
If you use Java threads then you need to handle the following requirements in your own code:
  • Synchronization with the main thread if you post back results to the user interface
  • No default for canceling the thread
  • No default thread pooling
  • No default for handling configuration changes in Android


AsyncTask enables proper and easy use of the UI thread. This class allows performing background operations and publishing results on the UI thread without having to manipulate threads and/or handlers. An asynchronous task is defined by a computation that runs on a background thread and whose result is published on the UI thread.
AsyncTask will go through the following 4 stages:
  1. onPreExecute()
    Invoked on the UI thread before the task is executed 

  2. doInbackground(Params..)
    Invoked on the background thread immediately after onPreExecute() finishes executing.
  3. onProgressUpdate(Progress..)
    Invoked on the UI thread after a call to publishProgress(Progress...). 

  4. onPostExecute(Result)
    Invoked on the UI thread after the background computation finishes.

Why should you use AsyncTask?

  1. Easy to use for a UI Thread. (So, use it when the caller thread is a UI thread).
  2. No need to manipulate Handlers.
  1. private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {    
  2.   ImageView bmImage;    
  3.   ProgressDialog pd;    
  4.   Context mContext;    
  6.   public DownloadImageTask(Context context,ImageView bmImage) {    
  7.       this.bmImage = bmImage;    
  8.       mContext = context;    
  9.   }    
  11.   public void onPreExecute() {    
  12.       pd = ProgressDialog.show(mContext, "Downloading","Downloading..Please Wait"true);      
  13.   }    
  15.   public void onPostExecute(Bitmap result) {    
  16.       pd.dismiss();    
  17.       if(result!=null){    
  18.           bmImage.setImageBitmap(result);    
  19.      }    
  20.   }   
  22.   protected Bitmap doInBackground(String... urls) {    
  23.       String urldisplay = urls[0];    
  24.       Bitmap bitmap = null;    
  25.       try {    
  26.         InputStream in = new java.net.URL(urldisplay).openStream();    
  27.         bitmap = BitmapFactory.decodeStream(in);    
  28.       } catch (Exception e) {    
  29.           Log.e("Error", e.getMessage());    
  30.           e.printStackTrace();    
  31.       }    
  32.       return bitmap;    
  33.   }    
  34. }   
You can see that, before starting background work, the progress dialog is shown to the user and after completion of background work the progress dialog is dismissed in "onPostExecute". So you can do UI changes in the same class implementation without using Handler and message passing.
To use this class, you need to write the following line:
  1. new DownloadImageTask (Activity.this, sourceImageView).execute(url1);  


In this article, we learned what the differences between Thread and AsyncTask are. Which is better for which condition. It's now clear when to use Thread and when to use AsyncTask.

Similar Articles