Home » Android » multithreading – Asynctask vs Thread in android

multithreading – Asynctask vs Thread in android

Posted by: admin March 11, 2020 Leave a comment

Questions:

In UI, to perform some background work, I used a separate Thread. But as suggested by others, I am now using AsyncTask.

What is the main difference between a Thread and an AsyncTask?

In which scenario, should I use a Thread or an AsyncTask?

How to&Answers:

For long-running or CPU-intensive tasks, there are basically two ways to do this: Java threads, and Android’s native AsyncTask.

Neither one is necessarily better than the other, but knowing when to use each call is essential to leveraging the system’s performance to your benefit.

Use AsyncTask for:

  1. Simple network operations which do not require downloading a lot of data
  2. Disk-bound tasks that might take more than a few milliseconds

Use Java threads for:

  1. Network operations which involve moderate to large amounts of data (either uploading or downloading)
  2. High-CPU tasks which need to be run in the background
  3. Any task where you want to control the CPU usage relative to the GUI thread

And there are lot of good resources over internet which may help you:

http://www.vogella.com/articles/AndroidBackgroundProcessing/article.html

Answer:

If you use Java threads you have 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

Answer:

Thread

  • Long task in general
  • Invoke by thread.start() method
  • Triggered from any thread
  • Runs on its own thread
  • Manual thread management/code may become difficult to read

AsyncTask

  • Small task having to communicate with main thread
  • Invoke by excute() method
  • Triggered from main thread
  • Runs on worker thread
  • Must be executed and created from the main thread

Answer:

Thread

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.

For further information visit Here

Answer:

Thread:

Thread should be used to separate long running operations from main thread so that performance is improved. But it can’t be cancelled elegantly and it can’t handle configuration changes of Android. You can’t update UI from Thread.

AsyncTask can be used to handle work items shorter than 5ms in duration. With AsyncTask, you can update UI unlike java Thread. But many long running tasks will choke the performance.

You have few more alternatives to both of them.

HandlerThread/ Handler and ThreadPoolExecutor

Refer to below post for more details:

Handler vs AsyncTask vs Thread