Android -Activity - Thread Basics

Question

I am still confused at threads. Still I could see some answers which points to threads, UI thread, background thread, main thread etc. (mostly on AsyncTasks and updating UI from background threads etc.)

Could anyone give me a complete explanation around these or some links at least?

It would be great if the answer covers the following cases:

Which are all the threads that's involved:

• When I am running an activity (setting the content view, attaching some buttons, some dialog messages)
• An activity with AsyncTask
• A Background Service
• A HTTP call

Answer 1

• UI thread (main thread) - it is crucial to instantiate (add) all UI elements on this thread, that is why it has a nickname UIThread
• AsyncTask - has methods doInBackground, onPostExecute, etc. Sort of its own lifecycle

• Background Service (service) A service runs by default in the same process as the application. in its own thread. (as pointed out by @MisterSmith) A service runs by default in the same process as the application. in its own thread. Therefore you need to use asynchronous processing in the service to perform resource intensive tasks in the background. Services which run in the process of the application are sometimes called local services. Thought you can specify to run a Service in its own process:

Running a service in its own process will not block the application in case the service performs long running operations in its main thread. But as the services runs in its own process you need to use some interprocess communication (IPC) to communicate to your service from other parts.

• HTTP call executed using HttpClient (from docs:

Thread safety of HTTP clients depends on the implementation and configuration of the specific client.

), has to be executed on non-UI thread by using new Thread(new Runnable(...)).start();, otherwise you will get NetworkOnMainThreadException thanks to @vikram. But it seems that HttpClient.execute() method is executed in a thread, that is why it requires a handler as one of the parameters in order to pass the result to the corresponding handler (handler runs on UI thread and can update widgets (UI elements) as it is needed)

Extra:

• To force something to be executed on your main thread use yourContextInstance.runOnUiThread(new Runnable(....));

• In order to determine if current thread is UI(main) thread:

Looper.getMainLooper().getThread() == Thread.currentThread();

Interesting question about threads in a service:

Does a runnable in a service run on the UI thread

Why UI thread is responsible for all this?

Because UI thread is in charge of dispatching the events to the appropriate widgets (UI elements), which includes the drawing events

Sources: this that and a little bit of that and some of that

Answer 2

When I am running an activity ( seting a content view , attaching some buttons, some dialog messages )

Usually only one thread (the main one, sometimes incorrectly called UI thread).

Activity - with async task

Again, by default only one (the main one). Menus and button handlers also run in the main thread. AsyncTask is a different story. It creates a worker thread (btw you should be careful not to leak it when exiting the activity).

Background Service

A service runs by default in the main thread. So do broadcast receivers. And this is why the main thread is not (only) the UI thread. Some types of services (like the popular IntentService) spawn a worker thread though.

An http Call

Is a synchronous operation, so it blocks until it completes (and this is why you should never perfom one in the main thread).

Answer 3

Technically speaking an application can have as many threads as it wants, they are arbitrarily created by the programmer.

However, the standard android application by default has one thread. That is the main thread, and is often referred to as the UI thread (as it is the only thread with access to the UI). By default everything happens in the main thread.

If you run an async task, different parts run in different threads, here's a basic breakdown:

onPreExecute() runs in the UI thread and is first called when you execute an async task. doInBackground() runs in a newly spawned thread separate from the main/UI thread. onPostExecute() runs in the UI thread after the background task returns.

A background service runs entirely separately from the application, it can run indefinitely even if the original application is destroyed.

An http call happens on whatever thread you call it on, but as a requirement of newer android API's you can no longer do any network activity from the main/UI thread. (This will actually cause an exception and terminate your application) This is to prevent slow network calls from blocking the main thread and therefore creating a choppy user experience.