Chapter 2. Performing Work with Looper, Handler, and HandlerThread

In the previous chapter, you were introduced to the most basic concurrent issues that a developer might face while developing a responsive and concurrent Android application. As the most interactable items run on the main thread, it is crucial to coordinate the backgrounds code to handle the work without any UI stuttering that compromises the user experience.

In this chapter, we will meet some of most fundamental constructs used on Android systems to perform tasks and schedule on a main thread or an ordinary background thread created by the developer to perform and schedule tasks long-running operations.

We will cover the following topics:

• Understanding Looper

• Understanding Handler

• Sending work to Looper

• Scheduling work with post

• Using Handler to defer work

• Leaking implicit references

• Leaking explicit references

• Updating the UI with Handler

• Canceling pending messages

• Multithreading with Handler and HandlerThread

• Applications of Handler...

Understanding Looper

Before we can understand Looper, we need to understand where it gets its name from.

Note

A loop is a group of instructions that are repeated continually until a termination condition is met.

Following this definition, Android's Looper executes on a thread that has a MessageQueue, executes a continuous loop waiting for work, and blocks when there is no work pending. When work is submitted to its queue, it dispatches it to the target Handler defined explicitly on the Message object.

Note

A message is a notification object containing a description and arbitrary data object that can be sent to a Handler.

The Looper on Android is an implementation of a common UI programming concept known as an event loop. Later, at the end of this processing sequence, the Handler will process the Message and execute your domain logic in order to solve an application user problem.

The Looper sequence on Android follows these steps:

1. Wait until a Message is retrieved from its MessageQueue

2. If logging...

Summary

In this chapter, we learned how to use Handler to queue work for the main thread and how to use Looper to build up a queueing infrastructure for our own Thread.

We saw the different ways in which we can define work with Handler: arbitrary work defined at the call site with Runnable or predefined work implemented in the Handler itself and triggered by message-sending.

In the meantime, we learned how to defer work properly without leaking memory on the way.

We learned how to use Handler in a multithreaded application to pass work and results back and forth between cooperating threads, performing blocking operations on an ordinary background thread and communicating the results back to the main thread to update the user interface.

In the next chapter, we'll start to build responsive applications by applying the AsyncTask instance to execute work in the background using pools of threads and returning progress updates and results to the main thread.