一、HandlerThread 初始化

---

初始化 HandlerThread , 特别注意 , 初始化完成后 , 紧跟着调用该线程的 start() 方法启动 ;

只有启动后 , HandlerThread 才会 初始化 Looper ,

Looper 初始化完成后 , 才能创建其中的 MessageQueue 消息队列 ,

有了 消息队列 MessageQueue , 才能获取 Handler ,

调用 getThreadHandler 方法获取 Handler , 或 自己创建 Handler ;

        // 1 . 初始化, 之后马上启动
        handlerThread = HandlerThread("handler")
        handlerThread.start()

HandlerThread -> Looper -> MessageQueue -> Handler

二、HandlerThread 获取Looper

---

HandlerThread 获取 Looper , 必须在 HandlerThread 启动之后 , 才能获取 Looper ;

        // 2 . 获取 Looper
        looper = handlerThread.looper

三、HandlerThread 获取消息队列 MessageQueue

---

HandlerThread 获取 MessageQueue , 从 Looper 中获取其中的 MessageQueue 消息队列 ,

在 6.0 之后 , 可以直接调用 getQueue 方法 , 获取消息队列 ,

在 6.0 之前 , 使用 反射 , 获取 Looper 中的 MessageQueue 消息队列 ;

        // 3 . 获取 消息队列 MessageQueue
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            messageQueue = looper.queue
        }else{
            // 反射获取 MessageQueue 消息队列
            // 设置访问字段
            var mQueue = Looper::class.java.getDeclaredField("mQueue")
            // 设置允许访问
            mQueue.isAccessible = true
            messageQueue = mQueue.get(looper) as MessageQueue
        }

四、HandlerThread 获取 Handler

---

创建 Handler , 可以通过上述获取的 子线程 Looper 创建 Handler , 将该 Looper 作为参数 , 传入 Handler 构造函数 , 即可创建该子线程对应的 Handler ;

该 Handler 运行在子线程中 , 因为该 Looper 是在子线程中 ;

        // 5 . 初始化 Handler
        handler = Handler(looper, {msg: Message ->
            Log.i(TAG, "运行任务 ${msg.what}")
            true
        })

五、HandlerThread 设置空闲队列

---

MessageQueue 消息队列 设置 IdleHandler 空闲任务 ,

IdleHandler 空闲任务实现 , 实现该 IdleHandler 接口的 queueIdle 方法 , 返回 true , 每次空闲时都会回调 , 如果返回 false , 则只会回调一次 ;

注册 IdleHandler , 调用 MessageQueue 消息队列的 addIdleHandler 注册空闲任务 ,

注销 IdleHandler , 调用 MessageQueue 消息队列的 removeIdleHandler 注销空闲任务

六、HandlerThread 代码示例

---

HandlerThread 代码示例 :

创建 HandlerThread , 注意创建后马上调用 start 方法执行 ,

获取对应的 Looper ,

获取 Looper 中封装的 消息队列 MessageQueue , 6.0 之后直接调用 getQueue 获取 , 6.0 之前使用反射获取 ,

设置空闲任务 IdleHandler , ( 可选 ) , 该空闲任务在 MessageQueue 队列为空时调用 , 一般用于刷新数据 , UI 等操作 ,

初始化 Handler , 可以自己创建 , 传入 Looper , 也可以调用 getLooper 方法获取系统提供的 Handler ,

使用 Handler 发送消息 ;

package kim.hsl.handler

import android.os.*
import android.os.Handler
import android.os.Looper
import android.os.Message
import android.os.MessageQueue
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlin.concurrent.thread

class MainActivity : AppCompatActivity() {
    val TAG = "MainActivity"

    lateinit var handlerThread : HandlerThread;
    lateinit var looper : Looper
    lateinit var messageQueue : MessageQueue
    lateinit var handler : Handler

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

        handler()
    }

    fun handler(){
        // 1 . 初始化, 之后马上启动
        handlerThread = HandlerThread("handler")
        handlerThread.start()

        // 2 . 获取 Looper
        looper = handlerThread.looper

        // 3 . 获取 消息队列 MessageQueue
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            messageQueue = looper.queue
        }else{
            // 反射获取 MessageQueue 消息队列
            // 设置访问字段
            var mQueue = Looper::class.java.getDeclaredField("mQueue")
            // 设置允许访问
            mQueue.isAccessible = true
            messageQueue = mQueue.get(looper) as MessageQueue
        }

        // 4 . 注册 IdleHandler
        messageQueue.addIdleHandler {
            Log.i(TAG, "空闲任务")
            // 注意这里返回 true, 表示每次空闲任务都执行一次
            true
        }

        // 5 . 初始化 Handler
        handler = Handler(looper, {msg: Message ->
            Log.i(TAG, "运行任务 ${msg.what}")
            true
        })

        // 6 . 子线程中发送消息 0
        thread (start = true) {
            handler.sendEmptyMessage(0)
        }
        // 7 . 主线程发送消息 1
        handler.sendEmptyMessage(1)

    }

}

运行结果 :