Android HandlerThread详解（源码分析）

最新推荐文章于 2022-01-18 19:55:52 发布
最新推荐文章于 2022-01-18 19:55:52 发布
阅读量507 收藏
点赞数
分类专栏： Android 文章标签： HandlerThread例子 HandlerThread源码 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jerechen/article/details/104080237
版权

目录：
目录

1. 前言

本篇文章是对 Android HandlerThread 类的学习，通过简单的例子，及分析源码来深入学习。同时例子将以 Java & Kotlin 两种代码形式展示。

1.1 定义

HandlerThread： 一个拥有 Looper 对象的线程。

继承于 Thread 类，并拥有一个 Looper 对象，可以利用该 Looper 对象来创建 Handler 对象，就像正常的线程一样，通过调用 start() 方法来开启线程。

1.2 使用场景

适用于子线程多任务的工作场景。如：在工作线程中进行多个网络请求，多个I/O操作，最典型的应用就是 IntentService，关于 IntentService 可以参考我的另一篇文章Android IntentService详解（源码分析）

2. 使用方法

其使用方法很简单：

  1. 在主线程中新建一个 HandlerThread 对象，然后调用 start() 方法启动该线程。
  2. 创建一个主线程Handler 对象，关联APP主Looper对象，用于子线程与主线程之间的沟通。
  3. 创建一个工作线程Handler 对象，关联 HandlerThread 的 Looper 对象。
  4. 发送消息给工作线程，工作线程Handler 接收消息，并处理消息，然后调用主线程。Handler，发送信息给主线程，通知主线程做UI工作。
  5. 当对应的 Activity 销毁时，退出 HandlerThread，终止消息循环。

比如：我们用两个 ProgressBar 来模拟在子线程中进行下载任务，点击按钮开始下载，ProgressBar 的进度代表着下载进度。
如下所示：

子线程执行多任务

2.1 Java版本

具体代码如下：

public class HandlerThreadActivity extends AppCompatActivity {
    private final int SET_PROGRESS_BAR_1 = 1;
    private final int SET_PROGRESS_BAR_2 = 2;
    private HandlerThread myHandlerThread;
    private Handler mWorkHandler, mMainHandler;
    private ProgressBar progressBar1, progressBar2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);

        TextView titleTv = findViewById(R.id.title_tv);
        titleTv.setText("HandlerThread");

        progressBar1 = findViewById(R.id.progress_bar_1);
        progressBar2 = findViewById(R.id.progress_bar_2);
        Button startBtn1 = findViewById(R.id.start_progress_bar_1_btn);
        Button startBtn2 = findViewById(R.id.start_progress_bar_2_btn);

        //创建HandlerThread对象
        myHandlerThread = new HandlerThread("myHandlerThread");
        //启动线程
        myHandlerThread.start();

        //创建主线程Handler，关联APP的主Looper对象
        mMainHandler = new Handler(getMainLooper());

        //创建工作线程Handler，关联HandlerThread的Looper对象，所以它无法与主线程通讯
        mWorkHandler = new Handler(myHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);

                switch (msg.what) {
                    case SET_PROGRESS_BAR_1:
                        //设置Progress Bar 1
                        for (int i = 1; i <= 4; i++) {
                            try {
                                //模拟耗时工作
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }

                            final int progressSchedule = i;
                            //在工作线程中，通过主线程Handler, 传递信息给主线程，通知主线程处理UI工作。
                            mMainHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    progressBar1.setProgress(progressSchedule);
                                }
                            });
                        }
                        break;
                    case SET_PROGRESS_BAR_2:
                        //设置Progress Bar 2
                        for (int i = 1; i <= 4; i++) {
                            try {
                                //模拟耗时工作
                                Thread.sleep(1300);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }

                            final int progressSchedule2 = i;
                            //在工作线程中，通过主线程Handler, 传递信息给主线程，通知主线程处理UI工作。
                            mMainHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    progressBar2.setProgress(progressSchedule2);
                                }
                            });
                        }
                        break;
                    default:
                        break;
                }
            }
        };

        startBtn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //通过工作线程Handler，mWorkHandler发送处理 progress bar 1 的信息给工作线程。
                Message msg = new Message();
                msg.what = SET_PROGRESS_BAR_1;
                mWorkHandler.sendMessage(msg);
            }
        });

        startBtn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //通过工作线程Handler mWorkHandler发送处理 progress bar 2 的信息给工作线程。
                Message msg = new Message();
                msg.what = SET_PROGRESS_BAR_2;
                mWorkHandler.sendMessage(msg);
            }
        });

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        myHandlerThread.quit();
    }
}

2.2 Kotlin版本

Kotlin 版本代码如下：

class TestHandlerThreadActivity : AppCompatActivity(), View.OnClickListener {
    private lateinit var mHandlerThread: HandlerThread
    private lateinit var mMainHandler: Handler
    private lateinit var mWorkHandler: WorkHandler

    override fun onClick(v: View?) {
        when (v?.id) {
            R.id.handlerThreadStart1Btn -> mWorkHandler.obtainMessage(1).sendToTarget()
            R.id.handlerThreadStart2Btn -> mWorkHandler.obtainMessage(2).sendToTarget()
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_test_handler_thread)

        mMainHandler = Handler(Looper.getMainLooper())

        mHandlerThread = HandlerThread("JereTest")
        mHandlerThread.start()
        mWorkHandler = WorkHandler(mHandlerThread.looper)

        handlerThreadStart1Btn.setOnClickListener(this)
        handlerThreadStart2Btn.setOnClickListener(this)
    }

    inner class WorkHandler(looper: Looper) : Handler(looper) {

        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            when (msg.what) {
                1 -> {
                    for (i in 1..5) {
                        Thread.sleep(1000)
                        mMainHandler.post { handlerThreadProgressBar1.progress = i }
                    }
                }
                2 -> {
                    for (j in 1..5) {
                        Thread.sleep(1000)
                        mMainHandler.post { handlerThreadProgressBar2.progress = j }
                    }
                }
            }
        }

    }

    override fun onDestroy() {
        super.onDestroy()
        mHandlerThread.quit()
    }

}

3. 源码分析

按使用步骤来分析源码：
HandlerThread使用方法

步骤一：在主线程中新建一个 HandlerThread 对象，然后调用 start() 方法启动该线程。

//创建 HandlerThread 对象
myHandlerThread = new HandlerThread("myHandlerThread");
//启动线程，执行 run() 方法
myHandlerThread.start();

//创建 HandlerThread 对象，看其构造函数
/**
 * HandlerThread的构造函数
 * @param name，线程名字是我们传入的，用于标记改线程
 */
public HandlerThread(String name) {
    super(name);
    //指定该线程的优先级为标准线程优先级
    mPriority = Process.THREAD_PRIORITY_DEFAULT;
}

//启动线程
@Override
public void run() {
    //获得线程标识符
    mTid = Process.myTid();
    //为该线程创建一个 Looper 对象，具体见下：
    Looper.prepare();
    synchronized (this) {
        //获取通过 Looper.prepare() 方法创建的 Looper 对象。
        mLooper = Looper.myLooper();
        //唤醒那些为创建Looper对象而阻塞的线程
        notifyAll();
    }
    //设置该线程的优先级，比如设置为标准线程优先级
    Process.setThreadPriority(mPriority);
    //消息循环前做的处理，即：如果想在消息循环前做一些处理，则需要复写onLooperPreopared()方法。
    onLooperPrepared();
    //循环该Looper对象中的消息队列
    Looper.loop();
    mTid = -1;
}

步骤二：创建一个主线程Handler 对象，关联APP主Looper对象，用于子线程与主线程之间的沟通。

//创建主线程Handler，关联APP的主Looper对象
mMainHandler = new Handler(getMainLooper());

其具体源码分析内容请看另外一篇文章Android Handler 深入学习及源码分析

步骤三. 创建一个工作线程Handler 对象，关联 HandlerThread 的 Looper 对象。
其具体实现方法如下：

//创建工作线程Handler，关联HandlerThread的Looper对象，所以它无法与主线程通讯
mWorkHandler = new Handler(myHandlerThread.getLooper()) {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
            ···略···
    }
};

通过 getLooper() 方法获取 HandlerThread 的 Looper 对象，其源码如下：

/**
 * 该方法返回该线程所关联的Looper对象。
 * 如果这个线程没有启动，或者由于任何原因isAlive()返回false，那么这个方法将返回null。
 * 如果这个线程已经启动，这个方法将阻塞，直到looper被初始化。
 * @return The looper.
 */
public Looper getLooper() {
    //线程未激活，返回 null
    if (!isAlive()) {
        return null;
    }
    
    //如果该线程已经启动，则阻塞该方法，直到创建好Looper对象。
    synchronized (this) {
        while (isAlive() && mLooper == null) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

步骤四：发送消息给工作线程，工作线程Handler 接收消息，并处理消息，然后调用主线程Handler，发送信息给主线程，通知主线程做UI工作。
Handler 通过 sendMessage(Msg) 及 post(Runnable) 方法传递消息，本篇博客不展开具体分析，具体源代码分析见上一篇博客Android Handler 深入学习及源码分析

步骤五：当对应的 Activity 销毁时，退出 HandlerThread，终止消息循环。
当当前 Activity 退出销毁时，复写 onDestry() 方法，退出 HandlerThread，如：

@Override
protected void onDestroy() {
    super.onDestroy();
    myHandlerThread.quit();
}

通过 quit() 方法退出 HandlerThread，终止消息循环，具体源代码分析，见下：

/**
 * 终止 Handler 关联的 looper 消息循环，不在处理消息队列中的任何消息。
 * 当 looper 被停止后再尝试请求消息入消息队列，会失败，比如：sendMessage(Message) 会返回 false。
 * 使用该方法可能不安全，因为 looper 在没有循环分发完所有消息时就被停止了。
 * 考虑使用quitsafe() 方法来代替，以确保所有未完成的工作以有序的方式完成。
 *
 * @return 如果Looper停止消息循环，返回True; 如果线程尚未开始运行，则返回false。
 */
public boolean quit() {
    //获取 Handler 所关联的 Looper 对象。
    Looper looper = getLooper();
    //如果 Looper 不为空，停止其消息循环，返回true
    if (looper != null) {
        looper.quit();
        return true;
    }
    //如果 Looper 为空，即线程还未开始运行，返回 false。
    return false;
}

/**
 * 安全的终止 Handler 关联的 Looper 消息循环，处理消息队列中所有已到期的消息，而未到期的挂起的延迟消息将不被传递
 * 处理完消息队列中的所有消息后立即停止 Looper 消息循环
 * 当 looper 被停止后再尝试请求消息入消息队列，会失败，比如：sendMessage(Message) 会返回 false。
 * 如果线程还未开始或已经结束（getLooper 返回 null），返回false；另外，当 Looper 被要求 quit() 停止消息循环时，返回true。
 *
 * @return 如果Looper停止消息循环，返回True; 如果线程尚未开始运行，则返回false。
 */
public boolean quitSafely() {
    Looper looper = getLooper();
    if (looper != null) {
        //
        looper.quitSafely();
        return true;
    }
    return false;
}

至此 HandlerThread 的源码也就分析结束了。
其实分享文章的最大目的正是等待着有人指出我的错误，如果你发现哪里有错误，请毫无保留的指出即可，虚心请教。

另外，如果你觉得文章不错，对你有所帮助，请给我点个赞，就当鼓励，谢谢～Peace~！

Jere_Chen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Android】HandlerThread详解
itbird的专栏
04-15 639
之前总结过Android Handler、Looper、Message、MQ的知识点，我们翻看源码的时候，看到一个关键类HandlerThread，当时还提出过疑问，这个和Thread有什么区别。本节，我们就结合实践来分析一下HandlerThread。 之前关于Android线程和进程的深入总结，各位有兴趣的建议，先看一下。 #Android进程和线程 1.源码解读 1.1 前言 大家看过上面我总结的handler、looper的相关文章的，一定看到过这样的总结片段。 至于具体原因，大家可以参看上.
Android异步之旅：探索HandlerThread
最新发布
weixin_63357306的博客
11-22 544
当我们在Android应用程序中需要执行一些耗时的任务，比如网络请求、数据库操作或者其他需要在后台线程中执行的操作时，我们通常会使用异步任务来完成这些任务。在Android中，有多种方式来实现异步操作，其中之一就是使用HandlerThread。在本篇博客中，我们将探索HandlerThread，了解它的工作原理以及如何在Android应用程序中使用它来进行异步操作。HandlerThread是Android中的一个类，它继承自Thread类，并且内部包含一个Looper和一个Handler。
Android基础之Handler分析，kotlin数据类
sa3221sa的博客
01-18 1300
//1.方式一：对当前线程的初始化，子线程要开启Looper必须调用该方法 public static void prepare() { prepare(true); //消息队列可以quit } private static void prepare(boolean quitAllowed) { if (sThreadLocal.get() != null) { //不为空表示当前线程已经创建了Looper throw new RuntimeException(“Only one Looper may
Android-kotlin实现网络请求库
08-13
kotlin fastjson HandlerThread 自定义注解 实现的网络请求库
Android多线程：HandlerThread详细使用手册(含实例讲解)
热门推荐
Carson带你学Android
02-08 3万+
前言 多线程的应用在Android开发中是非常常见的，常用方法主要有： 继承Thread类 实现Runnable接口 Handler AsyncTask HandlerThread 今天，我将全面解析多线程其中一种常见用法：HandlerThread 由于本文涉及多线程知识和Handler源码解析，所以阅读本文前建议先看： Android开发：Handler异步通信机制全面解...
Android实例HandlerThread源码分析
08-28
本篇文章主要给大家通过实例代码分析了Android中HandlerThread的用法以及步骤，需要的朋友参考学习下吧。
Android HandlerThread使用方法详解
08-29
Android HandlerThread 使用方法详解 Android HandlerThread 是 Android 中的一种线程机制，它继承自 Thread，并且内部封装了 Looper。HandlerThread 的主要用途是将耗时操作从主线程中抽离出来，避免阻塞主线程，...
Android HandlerThread的使用及原理详解
08-31
在Android开发中，`HandlerThread` 是一个非常重要的组件，它结合了线程（Thread）和消息处理（Handler）的功能，使得开发者可以在后台线程中高效地处理异步任务，尤其是那些需要定时或周期性执行的操作。...
深入Android HandlerThread 使用及其源码完全解析
01-20
HandlerThread是Android系统提供的一种线程管理工具，它在Android应用程序开发中扮演着重要的角色，尤其是在处理长时间运行的任务和保持线程的持续性方面。在Android的消息机制中，Handler、MessageQueue和Looper三...
实例分析Android中HandlerThread线程用法
01-05
一、HandlerThread的介绍及使用举例  HandlerThread是什么鬼？其本质就是一个线程，但是HandlerThread在启动的时候会帮我们准备好一个Looper,并供外界使用，说白了就是使我们在子线程中更方便的使用Handler，比如...
android HandlerThread 实例
04-01
在Android开发中，`HandlerThread` 是一个非常重要的组件，特别是在处理异步任务和线程通信方面。`HandlerThread` 是一个内置了Looper的线程，它可以为长时间运行的任务提供一个独立的消息处理循环，避免阻塞主线程...
android HandlerThread 使用demo
08-11
在Android开发中，`HandlerThread` 是一个非常重要的线程管理工具，它结合了线程和消息处理机制，常用于创建后台线程处理耗时任务，以避免阻塞主线程，提升用户体验。本示例（"android HandlerThread 使用demo"）将...
Android HandlerThread 全面解析
10-18
`HandlerThread`是Android提供的一种特殊线程类，它结合了线程和消息处理机制，使得开发者能够更方便地在后台执行耗时操作，同时与主线程进行通信。本文将全面解析`HandlerThread`的工作原理、使用方法以及它在实际...
Android SqliteManager 源码.rar
09-16
在这个“Android SqliteManager 源码.rar”压缩包中，我们可以深入理解SQLiteManager的工作原理以及如何在Android应用中实现类似的功能。 首先，SQLiteManager的核心功能是提供对SQLite数据库的操作接口。这些接口...
Thread、Handler和HandlerThread关系详解
09-01
HandlerThread的源码分析表明，它实际上就是一个拥有Looper的Thread。在运行时，它会调用Looper.prepare()初始化消息循环，并通过Looper.myLooper()获取到Looper对象。当Looper准备好时，会调用onLooperPrepared()...
Android多线程之HandlerThread详解
liuwg1226的专栏
04-11 745
一　HandlerThread介绍 当系统中有多个耗时任务需要执行时，每个任务都会开启一个新线程去执行耗时任务，这样会导致系统多次创建和销毁线程，从而影响性能。为了解决这一问题，Android 提供了 HandlerThread，HandlerThread 是在线程中创建一个 Looper 循环器，让 Looper 轮询消息队列，当有耗时任务进入队列时，则不需要开启新线程，在原有的线程中执行耗时任务即可，否则线程阻塞。 二　工作原理 HandlerThread 继承 Thread，在 Thread 开始执
Android中有关Handler的使用详解
逍遥飞鹤的专栏
06-22 942
Android中有关Handler的使用（一）          一个Handler允许你发送和处理消息（Message）以及与一个线程的消息队列相关的Runnable对象。每个Handler实例都和单个线程以及该线程的消息队列有关。当你创建了一个新Handler，它就会和创建它的线程/消息队列绑定，在那以后，它就会传递消息以及runnable对象给消息队列，然后执行它们。  
终止Android中HandlerThread的方法
yulongfei的专栏
09-01 2万+
尊重原创作者，转载请注明出处： http://blog.csdn.net/gemmem/article/details/7932655 如果我们在 activity中start了一个HandlerThread，那么这个线程会启动一个looper消息循环，当activity退出了，这个HandlerThread线程并没有终止，还是在那里做looper死循环，这当然不是我们愿意看到的。 我们
Android之使用HandlerThread 以及如何退出总结
码莎拉蒂
07-28 8419
1 、使用 HandlerThread handlerThread = new HandlerThread("handlerThread"); handlerThread.start(); //这里获取到HandlerThread的runloop MyHandler myHandler = new MyHandler(handlerThread.getLooper());
Android HandlerThread详解
这篇文档主要涵盖了Android开发中的一个重要概念——HandlerThread。HandlerThread是在Android系统中用于处理后台任务的一种线程类，它继承自Java的Thread类，但添加了对Looper的支持。Looper是Android消息机制的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值