Android 面试6——Handler 与 HandlerTh

本篇内容涉及到 Looper、Message、MessagQueue 等的知识

一、Handler

在非主线程中创建 Handler 时，会调用Looper.prepare()、Looper.loop() 等方法。

1. Looper

• Looper.prepare()
  在调用 prepare() 方法时，prepare() 方法中会有以下操作：

public static void prepare() {
    prepare(true);
}
 
private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

而 new Looper(quitAllowed) 构造器如下所示：

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

也就是，在调用 prepare() 方法后，就同时创建了 MessageQueue 对象并获取了 Looper 对象创建时所在的线程。
并且，将创建好的 Looper 对象，通过 sThreadLocal.set() 方法保存起来，以备后面 Handler 通过 sThreadLocal 获取到创建的 Looper 对象。

• Looper.loop()
  在 loop() 方法中有一个无限循环，通过 MessageQueue 的 next() 方法，不断取出 Message 对象。
  • 取出的消息为 null，结束循环并返回

        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
  

  • 设置消息为 null，通过 MessageQueue 的 quit() 与 quitSafely() 方法通知消息队列退出

public void quit() {
  mQueue.quit(false);
}

或者

public void quitSafely() {
  mQueue(true);
}

• 取出的消息不为空，通过 msg.target.dispatchMessage() 回调到 Handler 中

msg.target.dispatchMessage(msg);

2. Handler 处理消息

Looper 将消息回调到 Handler 的 dispatchMessage() 中进行处理

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

• 消息中有 callback，即通过 post(Runnable) 方式传递消息
• 若handler的mCallback不为空，则交由通过Callback创建handler方式去处理。
• 否则，由最常见创建handler对象的方式，在重写的handlerMessage中处理。

更详细内容，可参考这篇文章 深入理解Message, MessageQueue, Handler和Looper

二、HandlerThread

HandlerThread 在本质上就是在内部创建了自己的 Looper 的普通 Thread。

HandlerThread 的特点

• 将 loop 转移到子线程中处理，分担 MainLooper 的工作量
• HandlerThread 拥有自己的消息队列，不会干扰或阻塞 UI 线程
• 不适用于网络 IO 操作，因为其中只有一个线程，消息要排队执行

示例如下：

package com.example.handler_thread;

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

public class MainActivity extends AppCompatActivity {
    private TextView mainText;
    private HandlerThread handlerThread;
    // 子线程中的 Handler
    private Handler threadHandler;
    // 主线程中的 Handler
    private Handler mainHandler;

    // 防止页面退出后 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);
        mainText = findViewById(R.id.text_main);

        initThread();
    }

    private void initThread() {
        mainHandler = new Handler();
        handlerThread = new HandlerThread("handler-thread");
        handlerThread.start();

        threadHandler = new Handler(handlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                update();
                if(isUpdateInfo) {
                    threadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
                }
            }
        };
    }

    private void update() {
        try {
            Thread.sleep(1000 * 2);// 模拟耗时操作
            mainHandler.post(new Runnable() {
                @Override
                public void run() {
                    String result = "update every 2 seconds";
                    result += Math.random();
                    mainText.setText(result);
                }
            });
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        isUpdateInfo = true;
        // 发送消息，开始更新消息
        threadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 停止查询
        isUpdateInfo = false;
        threadHandler.removeMessages(MSG_UPDATE_INFO);
    }

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