Android ：安卓学习笔记之 Handler机制的简单理解和使用seo优化

Android ：安卓学习笔记之 Handler机制的简单理解和使用

news/2024/9/20 16:55:57

Handler机制
- 1、Handler使用的引出
2、背景和定义
3、作用和意义
4、主要参数
5、工作原理及流程
- 5.1、对应关系
6、深入分析 Handler机制源码
- 6.1、Handler机制的核心类
- 6.2、核心方法
  - 6.3、方式1：使用 Handler.sendMessage（）
    - 6.3.1、创建Handler类对象
    - 6.3.1.1、隐式操作1：创建循环器对象& 消息队列对象
    - 6.3.1.2、隐式操作2：消息循环
  - 6.3.2、创建消息对象
  - 6.3.3、在工作线程中发送消息到消息队列中
  - 6.3.4、总结
- 6.4、方式2：使用Handler.post()
  - 6.4.1、在主线程中创建Handler实例
  - 6.4.2、创建消息对象
  - 6.4.3、在工作线程中发送消息到消息队列中
  - 6.4.4、总结
  - 6.4.5、Handler.post和Handler.sendMessage的区别
- 6.5、MessageQueue分析
  - - 6.5.1、消息对象Message源码分析
    - 6.5.2、enqueueMessage是如何处理Message
- 6.6、Looper源码分析
  - 6.6.1、Looper#构造函数原理
  - 6.6.2、Looper.myLooper()原理
  - 6.6.3、Looper.prepare()原理
  - 6.6.4、Looper.loop()原理及总结
- 6.7、Handler机制的源码总结
7、具体使用案例
- 7.1、使用 Handler.sendMessage（）
  - 7.1.1、方式1：新建Handler子类（内部类）
  - 7.1.2、方式2：匿名内部类
- 7.2、使用 Handler.post（）

Handler机制

1、Handler使用的引出

有这样一个需求，当打开Activity界面时，开始倒计时，倒计时结束后跳转新的界面（思维活跃的朋友可能立马想到如果打开后自动倒计时，就类似于各个APP的欢迎闪屏页面），如下图：

可能觉得直接开启一个包含倒序循环的子线程就ok了，具体实现如下：

activity_main

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:tools="http://schemas.android.com/tools"android:id="@+id/activity_main2"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"tools:context="com.mly.panhouye.handlerdemo.Main2Activity"><TextViewandroid:gravity="center"android:textSize="30sp"android:layout_width="match_parent"android:layout_height="match_parent"android:text="NO DATA"android:id="@+id/tv"/>
</LinearLayout>

MainActivity.java

public class Main2Activity extends AppCompatActivity {TextView tv;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);tv = (TextView) findViewById(R.id.tv);new Thread(new Runnable() {@Overridepublic void run() {for (int i=5;i>0;i--){tv.setText(String.valueOf(i));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}//计时结束后跳转到其他界面startActivity(new Intent(MainActivity.this,MainActivity1.class));//添加finish方法在任务栈中销毁倒计时界面，使新开界面在回退时直接退出而不是再次返回该界面finish();}}).start();}

但当点进入界面时，会发现程序奔溃了，logcat中错误日志如下（只有UI线程可以更改UI界面）：

由此我们发现在安卓开发中，例如上面的示例，我们常常通过一个线程来完成某些操作，然后同步显示对应的视图控件UI上，通过上面的例子我们也知道了安卓中无法直接通过子线程来进行UI更新操作，对于这种情况，Android提供了一套异步消息处理机制Handler。

2、背景和定义

Handler一套 Android 消息传递机制,主要是子线程UI更细消息传递给主线程，从而主线程更新UI。

Android 主线程的UI，只能主线程更新。如果多个线程都能更新，势必要「加锁」，还不如采用「单线程消息队列机制」
主线程内部维护一个循环。没有消息时候，这个循环是阻塞的。新来消息(或者阻塞timeout)时会唤醒，接着处理新到来消息。

3、作用和意义

在多线程的应用场景中，将工作线程中需更新UI的操作信息传递到 UI主线程，从而实现工作线程对UI的更新处理，最终实现异步消息的处理
多个线程并发更新UI的同时保证线程安全

4、主要参数

（1）Message，线程之间传递的消息，用于不同线程之间的数据交互。Message中的what字段用来标记区分多个消息，arg1、arg2 字段用来传递int类型的数据，obj可以传递任意类型的字段。

（2）Handler，用于发送和处理消息。其中的sendMessage()用来发送消息，handleMessage()用于消息处理，进行相应的UI操作。

（3）MessageQueue，消息队列（先进先出），用于存放Handler发送的消息，一个线程只有一个消息队列。

（4）Looper，可以理解为消息队列的管理者，当发现MessageQueue中存在消息，Looper就会将消息传递到handleMessage()方法中，同样，一个线程只有一个Looper。

5、工作原理及流程

Handler机制的工作流程主要包括4个步骤：

1、异步通信准备
2、消息发送
3、消息循环
4、消息处理

工作流程图：

5.1、对应关系

线程（Thread）、循环器（Looper）、处理者（Handler）之间的对应关系如下：

1个线程（Thread）只能绑定 1个循环器（Looper），但可以有多个处理者（Handler）
1个循环器（Looper）可绑定多个处理者（Handler）
1个处理者（Handler）只能绑定1个循环器（Looper）

6、深入分析 Handler机制源码

6.1、Handler机制的核心类

Handler机制中有3个重要的类：

处理器类（Handler）
消息队列类（MessageQueue）
循环器类（Looper）

6.2、核心方法

下面的源码分析将根据 Handler的使用步骤进行

Handler使用方式因发送消息到消息队列的方式不同而不同，共分为2种：使用Handler.sendMessage（）、使用Handler.post（）

6.3、方式1：使用 Handler.sendMessage（）

/** * 此处以 匿名内部类 的使用方式为例*/// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象private Handler mhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}};// 步骤2：创建消息对象Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识msg.obj = "AA"; // 消息内容存放// 步骤3：在工作线程中 通过Handler发送消息到消息队列中// 多线程可采用AsyncTask、继承Thread类、实现RunnablemHandler.sendMessage(msg);// 步骤4：开启工作线程（同时启动了Handler）// 多线程可采用AsyncTask、继承Thread类、实现Runnable

6.3.1、创建Handler类对象

步骤1：在主线程中通过匿名内部类创建Handler类对象

/** * 具体使用*/private Handler mhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}};/** * 源码分析：Handler的构造方法* 作用：初始化Handler对象 & 绑定线程* 注：*   a. Handler需绑定 线程才能使用；绑定后，Handler的消息处理会在绑定的线程中执行*   b. 绑定方式 = 先指定Looper对象，从而绑定了 Looper对象所绑定的线程（因为Looper对象本已绑定了对应线程）*   c. 即：指定了Handler对象的 Looper对象 = 绑定到了Looper对象所在的线程*/public Handler() {this(null, false);// ->>分析1}
/** * 分析1：this(null, false) = Handler（null，false）*/public Handler(Callback callback, boolean async) {...// 仅贴出关键代码// 1. 指定Looper对象mLooper = Looper.myLooper();if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");}// Looper.myLooper()作用：获取当前线程的Looper对象；若线程无Looper对象则抛出异常// 即 ：若线程中无创建Looper对象，则也无法创建Handler对象// 故 若需在子线程中创建Handler对象，则需先创建Looper对象// 注：可通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象// 2. 绑定消息队列对象（MessageQueue）mQueue = mLooper.mQueue;// 获取该Looper对象中保存的消息队列对象（MessageQueue）// 至此，保证了handler对象 关联上 Looper对象中MessageQueue}

从上面可看出：

当创建Handler对象时，则通过构造方法自动关联当前线程的Looper对象 & 对应的消息队列对象（MessageQueue），从而自动绑定了实现创建Handler对象操作的线程

那么，当前线程的Looper对象 & 对应的消息队列对象（MessageQueue）是什么时候创建的呢？

在上述使用步骤中，并无创建Looper对象 & 对应的消息队列对象（MessageQueue）这1步

6.3.1.1、隐式操作1：创建循环器对象& 消息队列对象

创建Looper对象主要通过方法：Looper.prepareMainLooper()、Looper.prepare();
创建消息队列对象(MessageQueue)方法：创建Looper对象时则会自动创建，即：创建循环器对象(Looper)的同时，会自动创建消息队列对象(MessageQueue)

/** * 源码分析1：Looper.prepare()* 作用：为当前线程（子线程） 创建1个循环器对象（Looper），同时也生成了1个消息队列对象（MessageQueue）* 注：需在子线程中手动调用该方法*/public static final void prepare() {if (sThreadLocal.get() != null) {throw new RuntimeException("Only one Looper may be created per thread");}// 1. 判断sThreadLocal是否为null，否则抛出异常//即 Looper.prepare()方法不能被调用两次 = 1个线程中只能对应1个Looper实例// 注：sThreadLocal = 1个ThreadLocal对象，用于存储线程的变量sThreadLocal.set(new Looper(true));// 2. 若为初次Looper.prepare()，则创建Looper对象 & 存放在ThreadLocal变量中// 注：Looper对象是存放在Thread线程里的// 源码分析Looper的构造方法->>分析a}/** * 分析a：Looper的构造方法**/private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);// 1. 创建1个消息队列对象（MessageQueue）// 即 当创建1个Looper实例时，会自动创建一个与之配对的消息队列对象（MessageQueue）mRun = true;mThread = Thread.currentThread();}/** * 源码分析2：Looper.prepareMainLooper()* 作用：为 主线程（UI线程） 创建1个循环器对象（Looper），同时也生成了1个消息队列对象（MessageQueue）* 注：该方法在主线程（UI线程）创建时自动调用，即 主线程的Looper对象自动生成，不需手动生成*/// 在Android应用进程启动时，会默认创建1个主线程（ActivityThread，也叫UI线程）// 创建时，会自动调用ActivityThread的1个静态的main（）方法 = 应用程序的入口// main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象/** * 源码分析：main（）**/public static void main(String[] args) {... // 仅贴出关键代码Looper.prepareMainLooper(); // 1. 为主线程创建1个Looper对象，同时生成1个消息队列对象（MessageQueue）// 方法逻辑类似Looper.prepare()// 注：prepare()：为子线程中创建1个Looper对象ActivityThread thread = new ActivityThread(); // 2. 创建主线程Looper.loop(); // 3. 自动开启 消息循环 ->>下面将详细分析}

总结：

1、创建主线程时，会自动调用ActivityThread的1个静态的main（）；而main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象，同时也会生成其对应的MessageQueue对象

即主线程的Looper对象自动生成，不需手动生成；而子线程的Looper对象则需手动通过Looper.prepare()创建
在子线程若不手动创建Looper对象则无法生成Handler对象
2、根据Handler的作用（在主线程更新UI），故Handler实例的创建场景主要在主线程

3、生成Looper & MessageQueue对象后，则会自动进入消息循环：Looper.loop（），即又是另外一个隐式操作。

6.3.1.2、隐式操作2：消息循环

此处主要分析的是Looper类中的loop（）方法

/** * 源码分析： Looper.loop()* 作用：消息循环，即从消息队列中获取消息、分发消息到Handler* 特别注意：*       a. 主线程的消息循环不允许退出，即无限循环*       b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）*/public static void loop() {...// 仅贴出关键代码// 1. 获取当前Looper的消息队列final Looper me = myLooper();if (me == null) {throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");}// myLooper()作用：返回sThreadLocal存储的Looper实例；若me为null 则抛出异常// 即loop（）执行前必须执行prepare（），从而创建1个Looper实例final MessageQueue queue = me.mQueue;// 获取Looper实例中的消息队列对象（MessageQueue）// 2. 消息循环（通过for循环）for (;;) {// 2.1 从消息队列中取出消息Message msg = queue.next(); if (msg == null) {return;}// next()：取出消息队列里的消息// 若取出的消息为空，则线程阻塞// ->> 分析1 // 2.2 派发消息到对应的Handlermsg.target.dispatchMessage(msg);// 把消息Message派发给消息对象msg的target属性// target属性实际是1个handler对象// ->>分析2// 3. 释放消息占据的资源msg.recycle();}
}/** * 分析1：queue.next()* 定义：属于消息队列类（MessageQueue）中的方法* 作用：出队消息，即从 消息队列中 移出该消息*/Message next() {...// 仅贴出关键代码// 该参数用于确定消息队列中是否还有消息// 从而决定消息队列应处于出队消息状态 or 等待状态int nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态　nativePollOnce(ptr, nextPollTimeoutMillis);synchronized (this) {final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages;// 出队消息，即 从消息队列中取出消息：按创建Message对象的时间顺序if (msg != null) {if (now < msg.when) {nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);} else {// 取出了消息mBlocked = false;if (prevMsg != null) {prevMsg.next = msg.next;} else {mMessages = msg.next;}msg.next = null;if (DEBUG) Log.v(TAG, "Returning message: " + msg);msg.markInUse();return msg;}} else {// 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1// 下次循环时，消息队列则处于等待状态nextPollTimeoutMillis = -1;}......}.....}
}// 回到分析原处/** * 分析2：dispatchMessage(msg)* 定义：属于处理者类（Handler）中的方法* 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作*/public void dispatchMessage(Message msg) {// 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）// 上述结论会在讲解使用“post（Runnable r）”方式时讲解if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}// 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) ->> 分析3handleMessage(msg);}}/** * 分析3：handleMessage(msg)* 注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式**/public void handleMessage(Message msg) {  ... // 创建Handler实例时复写}

总结：

消息循环的操作 = 消息出队 + 分发给对应的Handler实例
分发给对应的Handler的过程：根据出队消息的归属者通过dispatchMessage(msg)进行分发，最终回调复写的handleMessage(Message msg)，从而实现消息处理的操作
特别注意：在进行消息分发时（dispatchMessage(msg)），会进行1次发送方式的判断：
1、若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息，则直接回调Runnable对象里复写的run（）
2、若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息，则回调复写的handleMessage(msg)

图表总结如下：

6.3.2、创建消息对象

/** * 具体使用*/Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识msg.obj = "AA"; // 消息内容存放/** * 源码分析：Message.obtain()* 作用：创建消息对象* 注：创建Message对象可用关键字new 或 Message.obtain()*/public static Message obtain() {// Message内部维护了1个Message池，用于Message消息对象的复用// 使用obtain（）则是直接从池内获取synchronized (sPoolSync) {if (sPool != null) {Message m = sPool;sPool = m.next;m.next = null;m.flags = 0; // clear in-use flagsPoolSize--;return m;}// 建议：使用obtain（）”创建“消息对象，避免每次都使用new重新分配内存}// 若池内无消息对象可复用，则还是用关键字new创建return new Message();}

6.3.3、在工作线程中发送消息到消息队列中

多线程的实现方式：AsyncTask、继承Thread类、实现Runnable

/** * 具体使用*/mHandler.sendMessage(msg);/** * 源码分析：mHandler.sendMessage(msg)* 定义：属于处理器类（Handler）的方法* 作用：将消息 发送 到消息队列中（Message ->> MessageQueue）*/public final boolean sendMessage(Message msg){return sendMessageDelayed(msg, 0);// ->>分析1}/** * 分析1：sendMessageDelayed(msg, 0)**/public final boolean sendMessageDelayed(Message msg, long delayMillis){if (delayMillis < 0) {delayMillis = 0;}return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);// ->> 分析2}/** * 分析2：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)**/public boolean sendMessageAtTime(Message msg, long uptimeMillis) {// 1. 获取对应的消息队列对象（MessageQueue）MessageQueue queue = mQueue;// 2. 调用了enqueueMessage方法 ->>分析3return enqueueMessage(queue, msg, uptimeMillis);}/** * 分析3：enqueueMessage(queue, msg, uptimeMillis)**/private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {// 1. 将msg.target赋值为this// 即 ：把 当前的Handler实例对象作为msg的target属性msg.target = this;// 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息// 实际上则是将该消息派发给对应的Handler实例        // 2. 调用消息队列的enqueueMessage（）// 即：Handler发送的消息，最终是保存到消息队列->>分析4return queue.enqueueMessage(msg, uptimeMillis）;}/** * 分析4：queue.enqueueMessage(msg, uptimeMillis）* 定义：属于消息队列类（MessageQueue）的方法* 作用：入队，即 将消息 根据时间 放入到消息队列中（Message ->> MessageQueue）* 采用单链表实现：提高插入消息、删除消息的效率*/boolean enqueueMessage(Message msg, long when) {...// 仅贴出关键代码synchronized (this) {msg.markInUse();msg.when = when;Message p = mMessages;boolean needWake;// 判断消息队列里有无消息// a. 若无，则将当前插入的消息 作为队头 & 若此时消息队列处于等待状态，则唤醒if (p == null || when == 0 || when < p.when) {msg.next = p;mMessages = msg;needWake = mBlocked;} else {needWake = mBlocked && p.target == null && msg.isAsynchronous();Message prev;// b. 判断消息队列里有消息，则根据 消息（Message）创建的时间 插入到队列中for (;;) {prev = p;p = p.next;if (p == null || when < p.when) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p; prev.next = msg;}if (needWake) {nativeWake(mPtr);}}return true;}// 之后，随着Looper对象的无限消息循环
// 不断从消息队列中取出Handler发送的消息 & 分发到对应Handler
// 最终回调Handler.handleMessage()处理消息

总结

Handler发送消息的本质 = 为该消息定义target属性（即本身实例对象） & 将消息入队到绑定线程的消息队列中。具体如下：

6.3.4、总结

6.4、方式2：使用Handler.post()

// 步骤1：在主线程中创建Handler实例private Handler mhandler = new mHandler();// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
// 需传入1个Runnable对象mHandler.post(new Runnable() {@Overridepublic void run() {... // 需执行的UI操作 }});// 步骤3：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable

实际上，该方式与方式1中的Handler.sendMessage（）工作原理相同、源码分析类似，下面将主要讲解不同之处

6.4.1、在主线程中创建Handler实例

/** * 具体使用*/private Handler mhandler = new  Handler()；// 与方式1的使用不同：此处无复写Handler.handleMessage()/** * 源码分析：Handler的构造方法* 作用：*     a. 在此之前，主线程创建时隐式创建Looper对象、MessageQueue对象*     b. 初始化Handler对象、绑定线程 & 进入消息循环* 此处的源码分析类似方式1，此处不作过多描述*/

6.4.2、创建消息对象

消息对象的创建 = 内部根据Runnable对象而封装

参考下一节（6.4.3）

6.4.3、在工作线程中发送消息到消息队列中

/** * 具体使用* 需传入1个Runnable对象、复写run()从而指定UI操作*/mHandler.post(new Runnable() {@Overridepublic void run() {... // 需执行的UI操作 }});/** * 源码分析：Handler.post（Runnable r）* 定义：属于处理者类（Handler）中的方法* 作用：定义UI操作、将Runnable对象封装成消息对象 & 发送 到消息队列中（Message ->> MessageQueue）* 注：*    a. 相比sendMessage()，post（）最大的不同在于，更新的UI操作可直接在重写的run（）中定义*    b. 实际上，Runnable并无创建新线程，而是发送 消息 到消息队列中*/public final boolean post(Runnable r){return  sendMessageDelayed(getPostMessage(r), 0);// getPostMessage(r) 的源码分析->>分析1// sendMessageDelayed（）的源码分析 ->>分析2}/** * 分析1：getPostMessage(r)* 作用：将传入的Runable对象封装成1个消息对象**/private static Message getPostMessage(Runnable r) {// 1. 创建1个消息对象（Message）Message m = Message.obtain();// 注：创建Message对象可用关键字new 或 Message.obtain()// 建议：使用Message.obtain()创建，// 原因：因为Message内部维护了1个Message池，用于Message的复用，使用obtain（）直接从池内获取，从而避免使用new重新分配内存// 2. 将 Runable对象 赋值给消息对象（message）的callback属性m.callback = r;// 3. 返回该消息对象return m;} // 回到调用原处/** * 分析2：sendMessageDelayed(msg, 0)* 作用：实际上，从此处开始，则类似方式1 = 将消息入队到消息队列，* 即 最终是调用MessageQueue.enqueueMessage（）**/public final boolean sendMessageDelayed(Message msg, long delayMillis){if (delayMillis < 0) {delayMillis = 0;}return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);// 请看分析3}/** * 分析3：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)**/public boolean sendMessageAtTime(Message msg, long uptimeMillis) {// 1. 获取对应的消息队列对象（MessageQueue）MessageQueue queue = mQueue;// 2. 调用了enqueueMessage方法 ->>分析3return enqueueMessage(queue, msg, uptimeMillis);}/** * 分析4：enqueueMessage(queue, msg, uptimeMillis)**/private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {// 1. 将msg.target赋值为this// 即 ：把 当前的Handler实例对象作为msg的target属性msg.target = this;// 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息// 实际上则是将该消息派发给对应的Handler实例        // 2. 调用消息队列的enqueueMessage（）// 即：Handler发送的消息，最终是保存到消息队列return queue.enqueueMessage(msg, uptimeMillis）;}// 注：实际上从分析2开始，源码 与 sendMessage（Message msg）发送方式相同

从上面的分析可看出：

消息对象的创建 = 内部根据Runnable对象而封装；
发送到消息队列的逻辑 = 方式1中sendMessage（Message msg）。

下面，我们重新回到步骤1前的隐式操作2：消息循环，即Looper类中的loop（）方法

/** * 源码分析： Looper.loop()* 作用：消息循环，即从消息队列中获取消息、分发消息到Handler* 特别注意：*       a. 主线程的消息循环不允许退出，即无限循环*       b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）*/public static void loop() {...// 仅贴出关键代码// 1. 获取当前Looper的消息队列final Looper me = myLooper();if (me == null) {throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");}// myLooper()作用：返回sThreadLocal存储的Looper实例；若me为null 则抛出异常// 即loop（）执行前必须执行prepare（），从而创建1个Looper实例final MessageQueue queue = me.mQueue;// 获取Looper实例中的消息队列对象（MessageQueue）// 2. 消息循环（通过for循环）for (;;) {// 2.1 从消息队列中取出消息Message msg = queue.next(); if (msg == null) {return;}// next()：取出消息队列里的消息// 若取出的消息为空，则线程阻塞// 2.2 派发消息到对应的Handlermsg.target.dispatchMessage(msg);// 把消息Message派发给消息对象msg的target属性// target属性实际是1个handler对象// ->>分析1// 3. 释放消息占据的资源msg.recycle();}
}/** * 分析1：dispatchMessage(msg)* 定义：属于处理者类（Handler）中的方法* 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作*/public void dispatchMessage(Message msg) {// 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息（即此处需讨论的）// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）->> 分析2if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}// 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) handleMessage(msg);}}/** * 分析2：handleCallback(msg)**/private static void handleCallback(Message message) {message.callback.run();//  Message对象的callback属性 = 传入的Runnable对象// 即回调Runnable对象里复写的run（）}

至此，你应该明白使用 Handler.post（）的工作流程与Handler.sendMessage（）类似，区别在于：

不需外部创建消息对象，而是内部根据传入的Runnable对象封装消息对象
回调的消息处理方法是：复写Runnable对象的run（）

6.4.4、总结

关于使用 Handler.post（）的源码解析完毕，总结如下：

6.4.5、Handler.post和Handler.sendMessage的区别

6.5、MessageQueue分析

首先来看看构造函数

MessageQueue(boolean quitAllowed) {mQuitAllowed = quitAllowed;mPtr = nativeInit();
}

构造函数之上定义了很多native方法

 private native static long nativeInit();private native static void nativeDestroy(long ptr);// 阻塞private native static void nativeWake(long ptr); // 唤醒private native static boolean nativeIsPolling(long ptr);private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);

native之上定义了几类数据结构，Message、ArrayList、SparseArray、数组

 Message mMessages; // 头结点private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;private IdleHandler[] mPendingIdleHandlers;

6.5.1、消息对象Message源码分析

Message有如下公有属性，供程序员调用：

public int what;//消息标示，
public int arg1; //简单int类型数据
public int arg2;//简单int类型数据
public Object obj;//简单Object类型数据
public Messenger replyTo;//跨进程信使
public int sendingUid = -1;//Messenger消息标示

Message有如下私有属性,用途如下：

/*package*/ static final int FLAG_IN_USE = 1 << 0;//正在使用中
/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;//消息同步标识
/*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;//
/*package*/ int flags;//消息执行标识
/*package*/ long when;//执行时间
/*package*/ Bundle data;//装载的数据
/*package*/ Handler target;//目标载体
/*package*/ Runnable callback;//任务线程
/*package*/ Message next;//消息链表，下一个消息private static final Object sPoolSync = new Object();//锁对象
private static Message sPool;//消息池
private static int sPoolSize = 0;//消息池大小
private static final int MAX_POOL_SIZE = 50;//消息池最大消息数常量
private static boolean gCheckRecycle = true;//循环检查

Message的源码，我们可以得出如下结论，Message是一种链表结构，每个Message持有以下信息：

1、用于传递的数据，如what、arg1、arg2、obj
2、用于执行当前Message的Handler
3、用于执行当前Message的回调接口CallBack、子线程Runnable
4、当前Message的属性，如延时时间、执行标识、Bundle数据，下一个Message引用。这种结构构成了链表。

6.5.2、enqueueMessage是如何处理Message

图中 1处会判断如果 Message 中的 target 没有被设置，则直接抛出异常；
图中2和 3 处会按照 Message 的时间 when 来有序得插入 MessageQueue 中，可以看出 MessageQueue实际上是一个链表维护的有序队列，只不过是按照 Message 的执行时间来排序。
看到这里，思路似乎终止了，我们跟随Handler、MessQueue的脚步，只看到了Message被插入到MessageQueue的私有队列中。那我们产生的Message什么时候会背消费呢？

接下来我们看看Looper吧！

6.6、Looper源码分析

在任何线程要开启Loop，都要用Looper.prepare()+Looper.looper()的方式。

以APP主进程为例，APP进程启动入口的main方法，也是通过这种方式开启loop的。与子线程细微不同的是，主线程开启looper用的是prepareMainLooper。

6.6.1、Looper#构造函数原理

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

Looper构造函数做了两件事情，初始化消息队列MessageQueue对象，记录当前线程信息。

6.6.2、Looper.myLooper()原理

/*** Return the Looper object associated with the current thread.  Returns* null if the calling thread is not associated with a Looper.*/
public static @Nullable Looper myLooper() {return sThreadLocal.get();
}

可以看到myLooper是从threadLocal中取出Looper对象。在Looper类中定义了如下变量sThreadLocal、mQueue、sMainLooper、mThread

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;  // guarded by Looper.classfinal MessageQueue mQueue;
final Thread mThread;

6.6.3、Looper.prepare()原理

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));
}

prepare就是 new 出一个 Looper。核心之处在于将 new 出的 Looper 设置到了线程本地变量 sThreadLocal 中。也就是说创建的 Looper 与当前线程发生了绑定。

Looper#prepareMainLooper原理

public static void prepareMainLooper() {prepare(false);synchronized (Looper.class) {if (sMainLooper != null) {throw new IllegalStateException("The main Looper has already been prepared.");}sMainLooper = myLooper();}
}

prepareMainLooper只有在APP进程启动的时候有用，并不推荐开发者调用这个函数。

6.6.4、Looper.loop()原理及总结

1、取出Looper对象
2 、校验当前线程是否持有Looper，是否启动而来Looper.prepare
3、从Looper中取出对应的MessageQueue，主线程Looper就取出主线程的MessageQueue，子线程就取出子线程MessageQueue
4 、从MessageQueue中取出Message
5、Message.target属性，即handler，调用Message绑定好的handler.dispatchMessage，处理消息。

也就是说，Message最终交由与Message绑定的Handler处理。Looper只是负责无限循环+从MessageQueue中读取。

6.7、Handler机制的源码总结

7、具体使用案例

1个简单 “更新UI操作” 的案例，主布局文件相同 = 1个用于展示的TextView，具体如下：

布局代码：activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"android:layout_height="match_parent"android:gravity="center"tools:context="com.example.carson_ho.handler_learning.MainActivity"><TextViewandroid:id="@+id/show"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="" />
</RelativeLayout>

7.1、使用 Handler.sendMessage（）

7.1.1、方式1：新建Handler子类（内部类）

public class MainActivity extends AppCompatActivity {public TextView mTextView;public Handler mHandler;// 步骤1：（自定义）新创建Handler子类(继承Handler类) & 复写handleMessage（）方法class Mhandler extends Handler {// 通过复写handlerMessage() 从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {// 根据不同线程发送过来的消息，执行不同的UI操作// 根据 Message对象的what属性 标识不同的消息switch (msg.what) {case 1:mTextView.setText("执行了线程1的UI操作");break;case 2:mTextView.setText("执行了线程2的UI操作");break;}}}@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);mTextView = (TextView) findViewById(R.id.show);// 步骤2：在主线程中创建Handler实例mHandler = new Mhandler();// 采用继承Thread类实现多线程演示new Thread() {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}// 步骤3：创建所需的消息对象Message msg = Message.obtain();msg.what = 1; // 消息标识msg.obj = "A"; // 消息内存存放// 步骤4：在工作线程中 通过Handler发送消息到消息队列中mHandler.sendMessage(msg);}}.start();// 步骤5：开启工作线程（同时启动了Handler）// 此处用2个工作线程展示new Thread() {@Overridepublic void run() {try {Thread.sleep(6000);} catch (InterruptedException e) {e.printStackTrace();}// 通过sendMessage（）发送// a. 定义要发送的消息Message msg = Message.obtain();msg.what = 2; //消息的标识msg.obj = "B"; // 消息的存放// b. 通过Handler发送消息到其绑定的消息队列mHandler.sendMessage(msg);}}.start();}
}

实验结果：

7.1.2、方式2：匿名内部类

public class MainActivity extends AppCompatActivity {public TextView mTextView;public Handler mHandler;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);mTextView = (TextView) findViewById(R.id.show);// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象mHandler = new Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {// 根据不同线程发送过来的消息，执行不同的UI操作switch (msg.what) {case 1:mTextView.setText("执行了线程1的UI操作");break;case 2:mTextView.setText("执行了线程2的UI操作");break;}}};// 采用继承Thread类实现多线程演示new Thread() {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}// 步骤3：创建所需的消息对象Message msg = Message.obtain();msg.what = 1; // 消息标识msg.obj = "A"; // 消息内存存放// 步骤4：在工作线程中 通过Handler发送消息到消息队列中mHandler.sendMessage(msg);}}.start();// 步骤5：开启工作线程（同时启动了Handler）// 此处用2个工作线程展示new Thread() {@Overridepublic void run() {try {Thread.sleep(6000);} catch (InterruptedException e) {e.printStackTrace();}// 通过sendMessage（）发送// a. 定义要发送的消息Message msg = Message.obtain();msg.what = 2; //消息的标识msg.obj = "B"; // 消息的存放// b. 通过Handler发送消息到其绑定的消息队列mHandler.sendMessage(msg);}}.start();}}

实验结果

7.2、使用 Handler.post（）

public class MainActivity extends AppCompatActivity {public TextView mTextView;public Handler mHandler;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);mTextView = (TextView) findViewById(R.id.show);// 步骤1：在主线程中创建Handler实例mHandler = new Handler();// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容new Thread() {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}// 通过psot（）发送，需传入1个Runnable对象mHandler.post(new Runnable() {@Overridepublic void run() {// 指定操作UI内容mTextView.setText("执行了线程1的UI操作");}});}}.start();// 步骤3：开启工作线程（同时启动了Handler）// 此处用2个工作线程展示new Thread() {@Overridepublic void run() {try {Thread.sleep(6000);} catch (InterruptedException e) {e.printStackTrace();}mHandler.post(new Runnable() {@Overridepublic void run() {mTextView.setText("执行了线程2的UI操作");}});}}.start();}}

实验结果：