android 线程loop

在 Android 中，"线程的 Looper" 是实现消息循环机制的核心组件，用于让线程能够持续处理消息（Message），是 Handler 机制的基础。它的设计目标是让普通线程从 "执行完任务就销毁" 变为 "可循环接收并处理消息"，从而支持异步通信（如主线程与子线程间的交互）。

一、Looper 的核心作用

创建消息队列（MessageQueue） ：每个 Looper 会关联一个唯一的 MessageQueue（消息队列），用于存储待处理的消息。
循环处理消息 ：Looper 会启动一个无限循环，不断从 MessageQueue 中取出消息，并分发给对应的 Handler 处理。
绑定线程 ：Looper 与创建它的线程一一绑定（通过 ThreadLocal 实现），确保消息在指定线程中处理。

二、Looper 的工作流程（核心步骤）

1. 初始化 Looper（线程关联）

普通线程默认没有 Looper，需手动初始化：

java

运行

复制代码

// 在子线程中初始化 Looper
new Thread(new Runnable() {
    @Override
    public void run() {
        // 1. 为当前线程创建 Looper 和 MessageQueue
        Looper.prepare();

        // 2. 创建 Handler（此时 Handler 会自动关联当前线程的 Looper）
        Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // 处理消息（运行在当前子线程）
                Log.d("Looper", "处理消息：" + msg.what);
            }
        };

        // 3. 发送消息（可以在其他线程发送，也可以在当前线程发送）
        handler.sendEmptyMessage(1);

        // 4. 启动消息循环（进入无限循环，处理消息）
        Looper.loop();
    }
}).start();

Looper.prepare()：为当前线程创建 Looper 实例（每个线程只能调用一次，否则抛异常），并初始化 MessageQueue。
Looper.loop()：启动消息循环，开始从 MessageQueue 取消息并处理。

2. 消息循环（Looper.loop () 的核心逻辑）

Looper.loop() 是一个无限循环，伪代码逻辑如下：

java

运行

复制代码

public static void loop() {
    // 获取当前线程的 Looper
    Looper me = myLooper();
    // 获取 Looper 关联的消息队列
    MessageQueue queue = me.mQueue;

    // 无限循环
    for (;;) {
        // 从消息队列取出消息（可能阻塞，直到有消息）
        Message msg = queue.next(); 
        if (msg == null) {
            // 消息为 null 时退出循环（通常是 Looper 退出时）
            return;
        }

        // 分发消息给对应的 Handler（msg.target 即发送消息的 Handler）
        msg.target.dispatchMessage(msg);

        // 回收消息到消息池
        msg.recycleUnchecked();
    }
}

阻塞机制 ：queue.next() 会阻塞线程，直到有新消息（如通过 Handler.send() 发送消息）或 Looper 退出。
消息分发 ：消息的 target 字段是发送它的 Handler，通过 dispatchMessage() 回调到 Handler.handleMessage() 处理。

3. 退出 Looper

Looper 的无限循环不会自动结束，需手动退出：

Looper.quit()：立即退出，清空消息队列中所有未处理的消息。
Looper.quitSafely()：安全退出，处理完当前队列中已有的消息后再退出。

退出后，loop() 方法会从循环中返回，线程执行完毕后销毁。

三、主线程的 Looper（UI 线程）

Android 主线程（ActivityThread）在启动时会自动初始化 Looper，无需手动调用 prepare() 和 loop()：

主线程启动时，系统会调用 ActivityThread.main() 方法，其中包含：

java

运行

复制代码

public static void main(String[] args) {
    // 初始化主线程 Looper
    Looper.prepareMainLooper(); 

    // 启动消息循环
    Looper.loop();

    // 如果 loop() 退出，说明主线程结束，抛出异常
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

prepareMainLooper() 是专门为主线程设计的 prepare() 方法，确保主线程 Looper 唯一且不可重复创建。
主线程的 Looper 永不退出（否则应用崩溃），因此主线程能持续处理 UI 事件、生命周期回调等消息。

四、关键特性总结

线程绑定 ：一个 Looper 对应一个线程，通过 ThreadLocal 存储，可通过 Looper.myLooper() 获取当前线程的 Looper。
消息驱动：线程的执行逻辑由消息队列中的消息驱动，避免了线程频繁创建销毁的开销。
Handler 依赖 ：Handler 必须与 Looper 关联才能发送 / 处理消息（创建 Handler 时若不指定 Looper，默认使用当前线程的 Looper）。

五、常见问题

子线程中创建 Handler 必须先初始化 Looper ：否则会报 Can't create handler inside thread that has not called Looper.prepare() 错误。
避免在主线程中做耗时操作：主线程的 Looper 处理消息时若耗时过长（如超过 5 秒），会导致 ANR（应用无响应），因为消息队列被阻塞，无法处理用户输入等事件。
Looper 与线程生命周期：Looper 的循环会让线程保持存活，若不手动退出 Looper，子线程会一直运行（可能导致内存泄漏）。

总之，Looper 是 Android 消息机制的 "心脏"，通过它，线程才能实现消息的循环处理，支撑起 Handler 机制的异步通信能力，是 UI 线程响应事件、子线程处理后台任务的核心基础。