HandlerThread的用法

最新推荐文章于 2024-05-11 20:28:42 发布
最新推荐文章于 2024-05-11 20:28:42 发布
阅读量2.5k 收藏 14
点赞数 1

http://blog.csdn.net/lskshz/article/details

一.介绍

HandlerThread继承自Thread，当线程开启时，也就是它run方法运行起来后，

线程同时创建了一个含有消息队列的Looper，并对外提供自己这个Looper对象的get方法，这就是它和普通Thread唯一不同的地方。

二.好处

为什么要使用HandlerThread。

1.开发中如果多次使用类似new Thread(){...}.start()

这种方式开启一个子线程，会创建多个匿名线程，使得程序运行起来越来越慢，

而HandlerThread自带Looper使他可以通过消息来多次重复使用当前线程，节省开支；

2.android系统提供的Handler类内部的Looper默认绑定的是UI线程的消息队列，

对于非UI线程又想使用消息机制，那么HandlerThread内部的Looper是最合适的，它不会干扰或阻塞UI线程。


三.用法

HandlerThread既然本质是Thread，为何前面加了一个Handler？

android中Handler类本质上就是从它内部的Looper中不断取消息，

然后触发它内部的Callback接口的handleMessage方法，让用户去实现对消息的具体处理。

而HandlerThread本身自带Looper,只要它实现了Callback接口，

那么HandlerThread也可以在自己线程内处理自己线程发出的消息，

充分实现非UI线程中较低开支下的消息处理



HandlerThread

如果已经理解Handler,Loop,MessageQueue的工作原理看此篇文章会非常简单，若没有了解的读者，可以看下面的文章： 
Handler类和Handler,Loop,MessageQueue的工作原理

首先我们先看一下官方的描述：

Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.

大致意思是HandlerThread能够新建拥有Looper的线程。这个Looper能够用来新建其他的Handler。（线程中的Looper）需要注意的是，新建的时候需要被回调。

用法

一般情况下，我们会经常用Handler在子线程中更新UI线程，那是因为在主线程中有Looper循环，而HandlerThread新建拥有Looper的子线程又有什么用呢？ 
必然是执行耗时操作。举个例子，数据实时更新，我们每10秒需要切换一下显示的数据，如果我们将这种长时间的反复调用操作放到UI线程中，虽说可以执行，但是这样的操作多了之后，很容易会让UI线程卡顿甚至崩溃。 
于是，就必须在子线程中调用这些了。 
HandlerThread继承自Thread，一般适应的场景，便是集Thread和Handler之所长，适用于会长时间在后台运行，并且间隔时间内（或适当情况下）会调用的情况，比如上面所说的实时更新。

其实使用HandlerThread的效果和使用Thread+Handler差不多。不过后者对开发者的要求更高。

效果

功能:每2秒更新一下UI。 
这里写图片描述

主要代码：

package com.example.double2.handlerthreadtest;

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    private TextView tvMain;

    private HandlerThread mHandlerThread;
    //子线程中的handler
    private Handler mThreadHandler;
    //UI线程中的handler
    private Handler mMainHandler = new Handler();

    //以防退出界面后Handler还在执行
    private boolean isUpdateInfo;
    //用以表示该handler的常熟
    private static final int MSG_UPDATE_INFO = 0x110;

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

        tvMain = (TextView) findViewById(R.id.tv_main);

        initThread();
    }


    private void initThread()
    {
        mHandlerThread = new HandlerThread("check-message-coming");
        mHandlerThread.start();

        mThreadHandler = new Handler(mHandlerThread.getLooper())
        {
            @Override
            public void handleMessage(Message msg)
            {
                update();//模拟数据更新

                if (isUpdateInfo)
                    mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
            }
        };

    }

    private void update()
    {
        try
        {
            //模拟耗时
            Thread.sleep(2000);
            mMainHandler.post(new Runnable()
            {
                @Override
                public void run()
                {
                    String result = "每隔2秒更新一下数据：";
                    result += Math.random();
                    tvMain.setText(result);
                }
            });

        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }

    }

    @Override
    protected void onResume()
    {
        super.onResume();
        //开始查询
        isUpdateInfo = true;
        mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
    }

    @Override
    protected void onPause()
    {
        super.onPause();
        //停止查询
        //以防退出界面后Handler还在执行
        isUpdateInfo = false;
        mThreadHandler.removeMessages(MSG_UPDATE_INFO);
    }

    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        //释放资源
        mHandlerThread.quit();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107

原理：

HandlerThread源码如下：

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }


    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }


    protected void onLooperPrepared() {
    }

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


    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }


    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }


    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }


    public int getThreadId() {
        return mTid;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77

首先我们可以看到HandlerThread继承自Thread，因此在run（）中的逻辑都是在子线程中运行的。

接下来就是两个关键的方法，run（）和getLooper（）： 
run（）中可以看到是很简单的创建Looper以及让Looper工作的逻辑。 
run()里面当mLooper创建完成后有个notifyAll()，getLooper()中有个wait()，这有什么用呢？因为的mLooper在一个线程中执行创建，而我们的handler是在UI线程中调用getLooper（）初始化的。 
也就是说，我们必须等到mLooper创建完成，才能正确的返回。getLooper();wait(),notify()就是为了解决这两个线程的同步问题。



xiao_FireFly
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Android HandlerThread使用方法详解
01-05
Android HandlerThread使用方法详解 HandlerThread 继承自Thread,内部封装了Looper。 首先Handler和HandlerThread的主要区别是：Handler与Activity在同一个线程中，HandlerThread与Activity不在同一个线程，而是别外...
Android HandlerThread的使用及原理详解
08-31
下面我们将深入探讨 `HandlerThread` 的使用方法和工作原理。 ### 一、HandlerThread的含义 `HandlerThread` 是 Android SDK 提供的一个类，它是 `Thread` 的子类，但与普通线程不同的是，`HandlerThread` 在启动...
HandlerThread 的简单使用
qq_42447739的博客
08-30 977
HandlerThread 1. HandlerThread是什么 HandlerThread继承自Thread，因此HandlerThread其实就是一个线程。 2. 使用流程 1.实例对象，参数为线程名字，（初始化参数为线程的名字） // A code block HandlerThread handlerThread = new HandlerThread("handlerThread"); ```javascript // An highlighted block 2. 启动线程 handlerT
HandlerThread的使用
qq_32664007的博客
05-20 518
正如前面所说，线程间通信的时候，比如Android中常见的更新UI，涉及到的是子线程和主线程之间的通信，实现方式就是Handler+Looper，但是要自己手动操作Looper，不推荐，所以谷歌封装了HandlerThread类（类似于AsyncTask类）。 上代码，具体实现： public class MainActivity extends AppCompatActivity { Handler mainHandler,workHandler; HandlerThread mHan
面试必问的一个知识点，关于HandlerThread的使用场景以及怎样使用-HandlerThread？
最新发布
2401_84009529的博客
05-11 717
有些同学老问我，快要校招了 今年的金三银四退成了金四银五了，我改准备哪些知识点去面试复习，然而要准备的知识点很庞大，今天要讲的知识其中之一。一篇关于的解析文档笔记~知识汇总的PDF相关内容后续GitHub更新,想冲击金三银四的小伙伴可以找找看看，欢迎star顺手留下GitHub链接，需要获取相关面试等内容的可以自己去找其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。
Android handlerthread使用详解
简公子的博客
05-12 385
在博客上看到这位兄弟前面讲的挺好，但是demo有点不对，我这边进行了调试；
HandlerThread的简单使用
qq_45877791的博客
11-08 53
猜测到 maybe 在 handler 中就有维护一个 looper 我们 looper 的创建都是在 Thread 的run方法中就已经帮我们创建好了 并进行 message 存取循环了。handlerthread 主要是用来开启异步线程进行操作的，但他的更加一个目的呢，是为了帮助我们开发的简便吧，帮我们开启了一个线程，默认封装好我们 handler 在子线程的常规操作。通过上方使用案例我们可以猜测，这个handlerThread 本身就是 Thread 的一个扩展类，我们可以从。
HandlerThread 浅析
Fibonacci的专栏
04-02 237
一. HandlerThread 源码分析HandlerThread  有三个成员变量：int mPriority; //线程的优先级，默认为：Process.THREAD_PRIORITY_DEFAULT int mTid = -1; //线程的标记 Looper mLooper; //线程的LoopermLooper  在 run() 方法中调用 Loo...
实例分析Android中HandlerThread线程用法
08-28
- 要在HandlerThread中使用Handler，需要将HandlerThread的Looper传递给Handler的构造函数。 ```java mHandler = new Handler(mHandlerThread.getLooper()); ``` 这样，Handler就运行在HandlerThread创建的线程...
深入Android HandlerThread 使用及其源码完全解析
08-27
下面我们将详细介绍每一步的使用方法。 首先，我们需要创建 HandlerThread 的实例对象。创建实例对象时，需要传递一个 String 参数，这个参数主要是标记当前线程的名字，可以任意字符串。例如： HandlerThread ...
Android--HandlerThread详解
超宇的博客
01-10 645
一、使用场景 举个例子，数据实时更新，我们每10秒需要切换一下显示的数据，如果我们将这种长时间的反复调用操作放到UI线程中，虽说可以执行，但是这样的操作多了之后，很容易会让UI线程卡顿甚至崩溃。 于是，就必须在子线程中调用这些了。 HandlerThread继承自Thread，一般适应的场景，便是集Thread和Handler之所长，适用于会长时间在后台运行，并且间隔时间内（或适当情况下）会调用
HandlerThread的使用以及注意事项
12-18
HandlerThread的使用以及注意事项
精通Android多线程视频教程
09-26
通过本课程的学习，让你透彻精通Android多线程编程，课程内容包括：1.UI线程和非UI线程2.使用Handler发送post请求3.使用Handler处理Message消息4.Handler、Looper、MessageQueue三者的关系5.UI线程Handler和工作线程Handler6.使用HandlerThread7.更新UI的方法8.使用AsyncTask
HandlerThread用法小结
tmpantian的专栏
11-14 3077
在文件SmsReceiverService.java文件中有这样一段代码       HandlerThread thread = new HandlerThread(TAG, Process.THREAD_PRIORITY_BACKGROUND);         thread.start();         mServiceLooper = thread.getLooper();
HandlerThread的使用以及原理
热门推荐
许佳佳的博客
02-28 2万+
HandlerThread 如果已经理解Handler,Loop,MessageQueue的工作原理看此篇文章会非常简单，若没有了解的读者，可以看下面的文章： Handler类和Handler,Loop,MessageQueue的工作原理 首先我们先看一下官方的描述： Handy class for starting a new thread that has a loo...
HandlerThread：使用方式
strugglelin'blog
07-24 191
1、定义 轻量级异步类。 2、作用 继承 Thread + 封装 Handler，方便顺序执行耗时任务。 3、具体使用 创建 HandlerThread 管理耗时任务执行。 创建 workHandler 执行具体耗时任务，绑定 HandlerThread 的 Looper 。 创建 uiHandler 执行具体 UI 更新。 workHandler 发送消息通知执行具体耗时任务。 pu...
Android开发之十五：Handler、Thread、HandlerThread三者的区别- Handler 四个使用实例 及HandlerThread的使用
随意的风的专栏
02-13 1777
一、前期知识储备 （1）Handler类，上官方文档，Handler public class Handler.A Handler allows you to send and process Messageand Runnable objects associated with a thread's MessageQueue. Each Handler instanceis associ...
Android之HandlerThread源码分析（第三篇：使用方式）
王员外的博客
03-13 663
每当创建HandlerThread对象后，调用它的start方法，一个带有Handler消息循环机制的工作线程就开始了它的工作，而我们要做的就是向它内部的MessageQueue发送消息、让我们的消息在工作线程得到处执行 0、无参 public Handler getThreadHandler() { if (mHandler == null) { ...
Android多线程-HandlerThread的简单使用与剖析
xiaomi987的专栏
04-24 939
前面我们讲到，Android中子线程与主线程通信我们主要用到Handler，在一些轻量级的需求上，可以使用AsyncTask。但是使用Handler有没有简单的方法实现主线程与子线程的通信呢。Android已经为我们内置了这么一个类HandlerThread，顾名思义，这是一个线程类，可以让我们更方便地实现线程间通信，那么，下面我们就通过一个简单的例子来了解一下这个类的使用方法。 简单使用 ...
handlerthread的用法
05-31
HandlerThread是一个Android中的工具类，它继承了Thread类并实现了Looper，可以用来在后台线程上执行一些消息处理任务。HandlerThread最常见的用法是在后台线程上执行一些耗时的任务，比如网络请求或者文件操作等。 下面是HandlerThread的使用步骤： 1. 创建HandlerThread对象 ```java HandlerThread handlerThread = new HandlerThread("handlerThread"); ``` 2. 启动HandlerThread线程 ```java handlerThread.start(); ``` 3. 获取HandlerThread线程的Looper对象 ```java Looper looper = handlerThread.getLooper(); ``` 4. 在HandlerThread线程上创建Handler对象 ```java Handler handler = new Handler(looper); ``` 5. 在Handler对象中处理消息 ```java handler.post(new Runnable() { @Override public void run() { // 在HandlerThread线程上执行的耗时任务 } }); ``` 在使用完HandlerThread之后，需要调用quit()方法来结束线程，释放资源。 ```java handlerThread.quit(); ``` 需要注意的是，HandlerThread的创建和启动需要在主线程中进行，但是HandlerThread中的消息处理是在后台线程中进行的。因此，在使用HandlerThread时需要注意线程间通信的问题。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值