In previous parts, we've delved into Handler, Looper and Message, understanding their roles in enabling code execution within a specified thread and facilitating safe communication between threads.

The HandlerThread class combines these concepts, simplifying the acquisition of Looper and Handler objects. In this article, we'll explore the implementation of HandlerThread referencing some AOSP code examples.

Internals of HandlerThread

HandlerThread extends the Thread class, providing additional functionality for initializing a Looper and Handler for the associated thread.

Here's the class definition:

/**
 * A {@link Thread} that has a {@link Looper}.
 * The {@link Looper} can then be used to create {@link Handler}s.
 * <p>
 * Note that just like with a regular {@link Thread}, {@link #start()} must still be called.
 */
public class HandlerThread extends Thread {
    // SajalRG: Implementation details...
}

UML class diagram of HandlerThread is shown below:

As demonstrated, HandlerThread essentially functions as a regular Java thread with added capabilities for constructing Looper and providing access to the Looper and Handler instances.

Recap: Construction of Looper

Examining the run() method of HandlerThread, we observe the process of Looper initialization, as discussed in first article of this series.

Looper.prepare() will create a new instance and can be called only once inside a Thread. Looper.loop() waits for message to appear in MessageQueue and process them. For detailed information and innerworking of this, I suggest to read this article.

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

Uses of HandlerThread

Now that we understand what HandlerThread is and how it operates, let's explore its practical utility.

Example1: Setting's App - WifiDialogActivity.java

In this example, HandlerThread is used to obtain a Handler object for the underlying Thread. View Full Code Here.

        if (mIsWifiTrackerLib) {
            // SajalRG: construct new HandlerThread
            mWorkerThread = new HandlerThread(
                    TAG + "{" + Integer.toHexString(System.identityHashCode(this)) + "}",
                    Process.THREAD_PRIORITY_BACKGROUND);
            mWorkerThread.start(); /* SajalRG: actually starts the thread */
            // SajalRG: other code removed for simplicity
            mNetworkDetailsTracker = FeatureFactory.getFactory(this)
                    .getWifiTrackerLibProvider()
                    .createNetworkDetailsTracker(
                            getLifecycle(),
                            this,
                            new Handler(Looper.getMainLooper()), /* SajalRG: passing handler for main looper */
                            mWorkerThread.getThreadHandler(), /* SajalRG: passing handler for the new thread */
                            elapsedRealtimeClock,
                            MAX_SCAN_AGE_MILLIS,
                            SCAN_INTERVAL_MILLIS,
                            mIntent.getStringExtra(KEY_CHOSEN_WIFIENTRY_KEY));
        }

Example 2: Camera2 App - CaptureModule.java

Here, HandlerThread is utilized to acquire a Looper for creating a new Handler object.View Full Code Here.

    @Override
    public void init(CameraActivity activity, boolean isSecureCamera, boolean isCaptureIntent) {
        // SajalRG: other code removed for simplicity
        HandlerThread thread = new HandlerThread("CaptureModule.mCameraHandler");
        thread.start(); /* Thread started */
        /* Create new Handler using looper from handler thread */
        mCameraHandler = new Handler(thread.getLooper());
        // SajalRG: other code removed for simplicity
}

Conclusion

HandlerThread simplifies the creation of a Looper, which otherwise would require manually extending Thread class and overloading the run() method with similar implementation. Understanding the functionality of HandlerThread equips us to leverage its benefits in our projects effectively.

In the next article, we'll address potential memory leak issues with Handler and how to mitigate them.

If you find these articles helpful, please consider liking or commenting to support future content. If you have any questions or topics you'd like covered, feel free to leave a comment below.