3

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
Ravindra babu
  • 37,698
  • 11
  • 250
  • 211
nullUser
  • 1,159
  • 2
  • 15
  • 26
  • Generally, everything is on main thread unless you use some threading API (AsyncTasks, Loaders etc), or start some threads yourself. – S.D. Aug 02 '13 at 11:26

3 Answers3

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

Community
  • 1
  • 1
Boris Mocialov
  • 3,439
  • 2
  • 28
  • 55
  • `HTTP call executed on main thread` will cause a `NetworkOnMainThreadException`. – Vikram Aug 02 '13 at 10:34
  • okay.. is there any way to know that if I am on UI thread ? What are the common issues on this ( accessing ui elements causes error sometimes ) – nullUser Aug 02 '13 at 10:37
  • @John because you cannot access UI elements from non-UI thread – Boris Mocialov Aug 02 '13 at 10:48
  • BG services: [From the developer guide](http://developer.android.com/guide/components/services.html): Caution: A service runs in the main thread of its hosting process—the service does not create its own thread and does not run in a separate process (unless you specify otherwise). – Mister Smith Aug 02 '13 at 10:49
  • @MisterSmith That is right, but the service itself can be viewed as a thread, because it runs independently of activity's UI thread – Boris Mocialov Aug 02 '13 at 10:52
  • @MisterSmith i think we are talking about different things – Boris Mocialov Aug 02 '13 at 10:57
  • @MisterSmith from your own link (From the developer guide) `A Service is an application component that can perform long-running operations in the background` – Boris Mocialov Aug 02 '13 at 10:58
  • Runs in the same process and in the same thread by default. And that's why the UIThread is not the UI's, but a main thread shared by every other component (again by default). – Mister Smith Aug 02 '13 at 11:10
  • @MisterSmith now i remembered this too. Thanks for pointing it out – Boris Mocialov Aug 02 '13 at 11:22
1

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).

Mister Smith
  • 27,417
  • 21
  • 110
  • 193
  • +1 in general. But, I think it's important to clarify what's meant by the phrase *"an http call"*. If you, for example, use `WebView#loadUrl()`, that call is performed asynchronously, and is safe to make on the main thread. I know you can argue that the "http call" is what's happening under the hood, on a background thread, but in the context of a beginner question like this, it's always good to be explicit. – Nate Aug 12 '13 at 02:02
0

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.

Rob Riddle
  • 3,544
  • 2
  • 18
  • 26
  • BG services: [From the developer guide](http://developer.android.com/guide/components/services.html): Caution: A service runs in the main thread of its hosting process—the service does not create its own thread and does not run in a separate process (unless you specify otherwise). – Mister Smith Aug 02 '13 at 10:49
  • I figured he was referring to an [IntentService](https://developer.android.com/training/run-background-service/index.html), which is known as a 'Background Service' colloquially. – Rob Riddle Aug 02 '13 at 10:53
  • That is your own terminology. All `Services` do thing "in background". – Mister Smith Aug 02 '13 at 10:55