This blog i started for sharing information for android developers.I just love to share my knowledge in my spare time and would appreciate any questions or feedback.

Thursday, June 28, 2012

Android Thread Constructs: Comparisons

In this series of posts we have seen the following thread constructs:
1. Basic threads and communication between them [see article]
2. Understanding the Main thread or the UI thread [see article]
3. IntentService [see article]
4. AsyncTask [see article]

NOTE: These are Android specific constructs. Android also
includes the java.util.concurrent package which can be leveraged for
concurrent tasks. That is out of the scope of my discussion.]

So, when to use what ? What is the exact purpose of each ? What are the
drawbacks of using one over the other ? Which one is easier to program ?

I came across all these questions when trying to understand each of
these. In due course of time, I have come up with some guidelines which I
discuss in this post.

NOTE: Any of the recommendations made in this post and the table
below are not comprehensive and final. There may be better and alternate
ways of doing things. I would love to know any different views and get
an insight into a different thought process. The views expressed in this
post are my personal views.

Service
Before proceeding further, let me touch on the Service class.
Traditionally speaking, the notion of service reminds us of task running
in the background while we can work and interact with the UI. This
causes confusion for newbies. Because in Android, even if the Service
runs in the background, it runs on the Main Thread of the application.
So, if at the same time if you have an activity displayed, the running
service will take the main thread and the activity will seem slow. It is
important to note that a Service is just a way of telling Android that
something needs to run without a user interface in the background while
the user may not interacting with your application. So, if you expect
the user to be interacting with the application while the service is
running and you have a long task to perform in a service, you need to
create a worker thread in the Service to carry out the task.
So, even if Service is not a threading construct, its a way of executing
a task at hand. Hence I have included it in the comparison.

Most
of the points in the table are self-explanatory. However, some points
that need an explanation are numbered and explained below the
table. Also, this table is just to summarize about the concepts
discussed in the previous posts. So, if anything is still unclear, I
recommend to go through each individual posts in this series.

Service

Thread

IntentService

AsyncTask

When to use ?

Task with no UI, but shouldn't be too long. Use threads within service for long tasks.

- Long task in general.

- For tasks in parallel use Multiple threads (traditional mechanisms)

- Long task usually with no communication to main thread.(Update)- If communication is required, can use main thread handler or broadcast intents[3]

- When callbacks are needed (Intent triggered tasks).

- Long task having to communicate with main thread.

- For tasks in parallel use multiple instances OR Executor [1]

Trigger

Call to method
onStartService()

Thread start() method

Intent

Call to method execute()

Triggered From (thread)

Any thread

Any Thread

Main Thread (Intent is received on main thread and then worker thread is spawed)

Main Thread

Runs On (thread)

Main Thread

Its own thread

Separate worker thread

Worker thread. However, Main thread methods may be invoked in between to publish progress.

Limitations /Drawbacks

May block main thread

- Manual thread management

- Code may become difficult to read

- Cannot run tasks in parallel.

- Multiple intents are queued on the same worker thread.

- one instance can only be executed once (hence cannot run in a loop) [2]

- Must be created and executed from the Main thread

[1]
API Level 11 (Android 3.0) introduces the executeOnExecutor() method,
that runs multiple tasks on a thread pool managed by AsyncTask. Below
API Level 11, we need to create multiple instances of AsyncTask and call
execute() on them in order to start parallel execution of multiple
tasks.