Android多线程 Handler、Looper线程 消息机制

单线程模型

Android 单线程模型是指：所有与 UI 相关的操作（如绘制、事件响应）必须在主线程（也称 UI 线程）中执行，而 Android UI 组件非线程安全，禁止在子线程直接更新 UI。‌‌

Thread、Looper、Handler、MessageQueue的包含关系

• 每个线程对应一个 Looper‌，保存在每个线程的线程本地存储 ThreadLocal 中；
• 每个线程可有多个 Handler 共享同一个 Looper 和 MessageQueue；

• ‌每个 Handler 绑定到线程的 Looper，Handler绑定到 Looper‌，不“包含”队列，是 Message 的发送者与处理者。‌‌

• Handler不一定创建在Looper线程中，只需要绑定到指定线程的Looper。

• Handler可指定绑定的Looper，不指定时则默认绑定到其创建线程的Looper

• 多个 Handler 可共享同一个线程的 Looper；
• ‌每个 Looper 持有一个 MessageQueue‌（在 Looper 构造时创建）；
• ‌MessageQueue 存储 Message 对象，
• 每个 Message 指定一个 target Handler 用于处理‌；

简言之：‌一个线程 → 一个 Looper → 一个 MessageQueue；一个线程→ 多个 Handler 可绑定同一个 Looper；Message 属于 MessageQueue ，Message由指定的 Handler 处理。‌‌‌

Handler

在Looper和Handler两者中，Looper实现了线程间通信，而Handler是对Looper的封装，是Looper的友好接口方便用户调用。而且Handler在各个线程间共享，以达到多线程通信的目的。

Handler是Android操作系统中的线程间通信工具，它主要由两个作用：

(1)安排消息或Runnable 在主线程中某个地方执行。

(2)安排一个动作在另外的线程中执行。

每个Handler对象维护两个队列(FIFO)：消息队列和Runnable队列， 都是由Android操作系统提供的。Handler可以通过这两个队列来分别：

• 发送、接受、处理消息–消息队列；
• 启动、结束、休眠线程–Runnable队列；

Handler的使用方法大体分为3个步骤：1.创建Handler对象。2.创建Runnable和消息。3.调用post以及sendMessage方法将Runnable和消息添加到队列。

Handler中的消息队列是引用的Looper中的消息队列。

Android的线程异步处理机制：Handler对象维护一个任务队列，有新的Runnable送来的时候,把它放在队尾，而处理 Runnable的时候，从队头取出Runnable执行。当向队列发送一个Runnable后，立即就返回，并不理会Runnable是否被执行，执行 是否成功等。而具体的执行则是当排队排到该Runnable后系统拿来执行的。

1. Handler与UI同线程时，可用于在子线程中通知主线程更新。

     诞生一个主线程的Handler物件，当做Listener去让子线程能将讯息Push到主线程的Message Quene里，以便触发主线程的handlerMessage（）函数，让主线程知道子线程的状态，并在主线程更新UI。
      例如，在子线程的状态发生变化时，我们需要更新UI。如果在子线程中直接更新UI,通常会抛出下面的异常，为此，需要通过Handler通知主线程Ui Thread来更新界面。

2.  在Android的开发中，在非UI线程中不能操作UI线程中的控件，即UI是非线程安全的；

     ProgressBar控件里面在一个线程中直接刷新进度条，看似违反了ANDROID的UI刷新原则，其实是这个函数里面自己做了同步操作。

Handler 的 post()方式或 send()方式发送消息，最终都是调用了 sendMessageAtTime()方法。Activity 中的 runOnUiThread()中更新 UI，其实也是发送消息 通知主线程更新 UI，最终也会调用 sendMessageAtTime()方法。

Handler postDelay 方法原理

判断如果这 个 Message 有延迟，就调用 nativePollOnce(ptr, nextPollTimeoutMillis)进行阻塞。 nativePollOnce()的作用类似与 object.wait()。得出结论是通过阻塞实现的。

如果在阻塞这段时间里有无延迟 message 又加入 MessageQueen 中是怎么实现立即处理这个 message 的？

如果当前插入的消息不是延迟 message，或比当前的延迟短， 这个消息就会插入头部并且唤起线程nativeWake(mPtr)(唤起线程)。

Handler 引起的内存泄露的原因以及解决方案

Handler如果发送延时消息，然后在延时期间用户关闭了 Activity，那么该 Activity会Destroy但其内存却不会释放导致内存泄露。内存泄露是因为 Message 持有 Handler，而Java 非静态内部类持有外部类，使得 Activity 被 Handler 持有，最终就导致 Activity 泄露。

解决该问题的最有效的方法是将 Handler 定义成静态内部类，在内部持有 Activity 的弱引用，并在Activity销毁前通过Handler清空消息队列。

Looper

一个简单的 main 函数执行完毕后，整个进程也就结束了，为了让一个进程长时间的运行下去，就需要 无限循环加事件通知的机制。

一个典型的Looper线程示例：

// 典型的关于Handler/Looper的线程
class LooperThread extends Thread {
    public Handler mHandler;
    public void run() {
        //为当前线程初始化Looper
        Looper.prepare();   
        mHandler = new Handler() {  
            public void handleMessage(Message msg) {
                //定义消息处理逻辑. 
                Message msg = Message.obtain();
            }
        };
        //启动Looper
        Looper.loop();  
    }
}

// 其他线程向此looper线程发送一个消息
looperThread.mHandler.sendEmptyMessage(0);

使用上来说：

在Looper 线程中：

调用Looper.prepare()初始化 Looper
初始化一个 Handler 对象
Looper .loop() 进入循环休眠状态

在其他线程中：

获取到 Looper 线程中的 Handler 对象
构建一个 Message 对象
调用 Handler 对象的 sendMessage 发送消息给 Looper

Looper有一个静态的 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); 成员变量，ThreadLocal本质上是一系列线程号和Looper对象的key-value键值对，因为sThreadLocal是静态的，所以它为所有的线程所共享。 而sThreadLocal.get()就是获取当前线程对应的Looper。Looper.prepare()就是重新创建一个Looper，查看Looper源码可看到调用了sThreadLocal.set(new Looper(quitAllowed)); 也就是往sThreadLocal插入了一个键值对。 另外一个Looper有一个MessageQueue，用来存储Message。

HandlerThread

• android.os.HandlerThread线程类，它具有消息处理能力，其内部创建了Looper消息循环实现线程间通信。
• 适用于子线程持续性任务，并且需要和主线程之间通信的场景。
• 使用方式：
  • 创建HandlerThread并start，它会轮询内部的消息队列。
  • 创建静态Handler绑定HandlerThread的Looper，实现消息处理。
  • 通过Handler发送消息。
• 需手动调用quit/quitSafely销毁资源。

Android 线程优先级

Android优先级范围：通过android.os.Process.setThreadPriority()可设置更精细的优先级(−20∼19)，值越小优先级越高（UI线程默认为-10）。

通过setThreadPriority设置的优先级和通过thread.setPriority设置的优先级是隔离的。

• JDK限制：Thread.setPriority()设置效果不明显，且超出[1∼10]范围会抛出IllegalArgumentException。
• Android优化机制：Process.setThreadPriority()对线程调度有明显影响，设计目的是让UI线程获取更多CPU时间片提高响应速度。
• 作用域隔离：两种设置方式互不影响，Process.setThreadPriority()不会改变Thread.getPriority()的返回值。

消息的消费

1.消息分发

消息的分发依赖于队列中的路牌机制，通过该机制实现消息的传递与处理。

1) Looper类的loop方法

• loop方法通过无限循环实现消息的持续分发，确保线程不会退出。
• MessageQueue.next()方法获取可执行的Message对象，若队列中无消息，线程将进入阻塞状态。MessageQueue.next()方法的逻辑复杂，涉及消息的插入、删除及队列的动态调整。
• 消息分发优先级：获取消息后调用message.target.dispatchMessage()进行分发，处理完成后通过recycleUnchecked()回收消息。

2) MessageQueue类的next方法

• next方法通过无限循环检索消息，若未找到可处理的消息，线程将根据nextPollTimeoutMillis值进入阻塞状态（正数：定时阻塞；-1：无限阻塞）。
• 线程唤醒：新消息插入时（如Binder线程插入Activity生命周期消息）会唤醒阻塞线程。
• 延迟消息机制：通过SystemClock.uptimeMillis()计算消息执行时间，结合epoll命令实现阻塞超时后自动恢复检查。
• 同步屏障消息：若队列头部为同步屏障消息（target=null），则优先检索异步消息执行。
• 消息删除逻辑：
  • 中间节点删除：调整前驱节点的next指向被删除节点的后继节点。
  • 头节点删除：直接调整队列头指针指向后继节点。
• 空闲状态处理：在next方法中如果检测到空闲则会通过IdleHandler执行设置的小任务。使用IdleHandler的正确的方法 将启动过程中非紧急的主线程任务全部放进一个任务列表里，然后一个执行一个小任务，并切记单个消息耗时不要太长。

2.C++层代码分析

• native方法：Java层的nativePollOnce调用C++的Looper::pollOnce，最终通过Linux的epoll_wait监听文件变动（如屏幕输入、外设消息）。
• 线程唤醒：C++层执行完毕后调用awaken唤醒Java线程。
• 两套消息机制：Java与C++层的消息机制相互独立，Java层借助native方法实现线程阻塞能力。

AsyncTask

异步任务抽象类android.os.AsyncTask相对来说更轻量级一些，适用于简单的异步处理。

• 特点：轻量级异步任务工具类，提供任务执行进度回调给UI线程。
• 适用场景：需要知晓任务执行进度，多个任务串行执行。
• 缺点：生命周期与宿主不同步可能造成内存泄漏，默认串行执行任务。

三种执行方式：

• 子类复写方法（可计算进度时）
• AsyncTask.execute静态方法（串行执行），不需要进度。
• executeOnExecutor中使用THREAD_POOL_EXECUTOR并发线程池来并发执行，或使用AsyncTask.THREAD_POOL_EXECUTOR.execute静态方法并发执行。

使用AsyncTask时必须遵守如下规则：

• 必须在UI线程中创建AsyncTask的实例，以及调用AsyncTask的execute()方法。
• AsyncTask 的 onPreExecute()、onPostExecute(Result)、doInBackground (Params...params)、onProgressUpdate(Progress...values)方法，不应该主动调用，而是由Android系统调用。
• 每个AsyncTask只能被执行一次，多次调用将会引发异常。

在子线程中进行 UI 操作的方法

• View 的 postInvalidate()方法。View通过mAttachInfo.mHandler发送持invalidate事件，源码如下：  

public void postInvalidate() {
        postInvalidateDelayed(0);
}
public void postInvalidateDelayed(long delayMilliseconds) {
        // We try only with the AttachInfo because there's no point in invalidating
        // if we are not attached to our window
        if (mAttachInfo != null) {
            Message msg = Message.obtain();
            msg.what = AttachInfo.INVALIDATE_MSG;
            msg.obj = this;
            mAttachInfo.mHandler.sendMessageDelayed(msg, delayMilliseconds);
        }
}

• View.post(Runnable action)‌：通过任意已附加到窗口的 View 发送 Runnable 到主线程消息队列，简单轻量，适合局部 UI 更新。

• Handler(Looper.getMainLooper())‌：在主线程创建 Handler，子线程通过 sendMessage() 或 post() 发送消息/任务，由主线程的 Handler 处理。

• Activity 的 runOnUiThread(Runnable action)‌：在 Activity 中调用，将 Runnable 投递到主线程执行，适用于有 Activity 上下文的场景。

• 现代替代方案（如 Kotlin 协程或 Executor + Handler）‌：推荐使用 withContext(Dispatchers.Main)（Kotlin 协程）或 Handler 配合线程池，避免手动管理线程。‌‌

异步不一定要切换线程，关键是要切换函数调用栈

handler.post、handler.send也是异步调用，虽然没有切换线程，但它同样因为调用栈的切换而一定程度上影响了我们对于逻辑执行的把控。也就是说，handler的执行体执行会晚于handler调用语句之后的语句，并且执行于handler对应的looper线程中，looper线程也可能就是调用所在的线程。异步不一定要切换线程，关键是要切换函数调用栈。异步与切换线程的关系：一旦线程发生切换，那么函数调用栈必然切换，自然就产生了异步操作，而异步不一定需要切换线程，因此切换线程是异步的充分不必要条件。