Why there is AsyncTask in android?

Question

Why use asynchronous task in android for executing tasks?, task can be execute directly in ui thread. Is there any restriction in ui thread?

Answer 1

Is there any restriction in ui thread?

The main application ("UI") thread drives your user interface. If you tie up that thread doing your own work, while that work is going on, your UI will be frozen. Updates you try to make will not take place until you allow the main application thread to get back to its normal work. Also, touch events from the user will not respond while you have the main application thread tied up.

The problem is that, unless you are told otherwise, any time that Android code calls your code in the form of one of your callback methods, it will do so on this main application thread.

My general recommendation is that the work to be done in any individual callback method (e.g., onCreate(), getView(), onListItemClick()) needs to take well under 1ms. Many such callbacks are invoked as part of UI processing. If you spend too much time, you may "drop frames" (i.e., prevent the UI from updating at the desired 60 frames-per-second rate) and thereby cause "jank".

An AsyncTask is one way of helping to move work off the main application thread, while still making it reasonably convenient to update the UI with the results of that work. Generally, you cannot update the UI from a background thread, though there are some exceptions (e.g., ProgressBar).

Answer 2

For the security purpose, if there is any long process ( more than 5 seconds ) going on in UI Thread, Android OS will terminate that application.

So to solve such Exception and for long running operations like downloading data from network, Android has introduce a new class named AsyncTask.

AsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers.

Answer 3

A thread is a concurrent unit of execution. It has its own call stack. There are two methods to implement threads in applications.

One is providing a new class that extends Thread and overriding its run() method. 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 affect 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

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:

onPreExecute()

Invoked on the UI thread before the task is executed

doInbackground(Params..)

Invoked on the background thread immediately after onPreExecute() finishes executing.

onProgressUpdate(Progress..)

Invoked on the UI thread after a call to publishProgress(Progress...).

onPostExecute(Result)

Invoked on the UI thread after the background computation finishes. Why should you use AsyncTask?

• Easy to use for a UI Thread. (So, use it when the caller thread is a UI thread).
• No need to manipulate Handlers.

Use AsyncTask for:

• Simple network operations which do not require downloading a lot of data

• Disk-bound tasks that might take more than a few milliseconds

Use Java threads for:

• Network operations which involve moderate to large amounts of data (either uploading or downloading)

• High-CPU tasks which need to be run in the background

• Any task where you want to control the CPU usage relative to the GUI thread