作用：
多线程模式下，用于线程间的数据传递，子线程跟新ui等操作。
在学习怎么使用前，需要认识几个重要的概念
- Message：线程间传递的消息（线程通讯的数据单元）
- Handler ：消息的发送和处理者，（子线程和主线程的通信媒介）
- MessageQueue ：存放handler发送的message（一种数据结构）
- Looper ： 消息循环，消息的获取和分发（MessageQueue和Handler的通信媒介）
使用方式
- sendMessage()用法
- 新建Handler子类，重写HandleMessage方法（处理子线程传来的message）
class Mhandler extends Handler {
@Override
public void handleMessage(Message msg) {
// 根据不同线程发送过来的消息，执行不同的UI操作
// 根据 Message对象的what属性 标识不同的消息
switch (msg.what) {
case 1:
mTextView.setText("执行了线程1的UI操作");
break;
case 2:
mTextView.setText("执行了线程2的UI操作");
break;
}
}
}
- 在主线程创建Mhandler对象，handleMessage里的逻辑在创建handler对象的线程中执行，此时就是在主线程执行。
private Handler mhandler = new mHandler();
- 在子线程发送Message
new Thread() {
@Override
public 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();
- post()使用方法
- 同上步骤1
- 同上步骤2
- 在子线程中post一个Runnable进行修改ui等耗时操作
new Thread() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 通过psot（）发送，需传入1个Runnable对象
mHandler.post(new Runnable() {
@Override
public void run() {
// 指定操作UI内容
mTextView.setText("执行了线程1的UI操作");
}
});
}
}.start();
注意我们的Runnable中的代码是在主线程中执行的，因为mHandler.post(R)中 的 R是在handler实例化的那个线程中执行。
工作原理
工作流程大概分为四个步骤：
- 异步通信准备：在主线程中创建，handler，looper，messageQueue，创建完成后，handler自动绑定主线程的looper和messageQueue。
- 消息发送： 子线程通过handler发送message到messageQueue中，
- 消息循环： looper获取消息队列外面的一个message，然后分发给消息的处理者handler
- 消息处理： handler接收looper传来的message，然后在handleMessage()中根据message.what分别处理对应的message。
工作流程图：
流程图
流程图解析:首先我们看图上有两个线程，一个是主线程，一个是子线程，主线程里有一个handler，一个messageQueue，一个looper，子线程里有好多好多的message，第一步，我们在子线程中调用handler的sendMssage方法，将message发送到主线程的messageQueue中，然后looper获取messageQueue中最前面的message，分发给handler调用handleMessage处理。如果消息队列为空则线程将会处于阻塞状态。
注意点： - 一个线程只有一个looper，可以有多个handler
- 一个looper可以绑定多个handler
- 一个handler只能绑定一个looper
sendMessage方法源码分析
核心API
具体介绍
handler的构造
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的构造方法：初始化handler对象&绑定线程。
handler需要绑定线程才能正常工作，给handler指定一个looper，即给他绑定了一个线程，（因为looper对象本身已经绑定了对应线程），在handler的构造方法中，先绑定looper，又指定了messageQueue。
在handler构造之前：循环器对象（Looper） & 消息队列对象（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. 自动开启 消息循环 ->>下面将详细分析
}
- prepare() ： 为子线程创建一个looper，同时创建一个messageQueue对象，注：需要在子线程手动调用prepare()，
- prepareMainLooper(): 主线程会自动调用main()，main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象，同时也会生成其对应的MessageQueue对象
TIPS:
即主线程的Looper对象自动生成，不需手动生成；而子线程的Looper对象则需手动通过Looper.prepare()创建,在子线程若不手动创建Looper对象 则无法生成Handler对象
在handler构造前，消息循环：
/**
* 源码分析： 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 派发消息到对应的Handler
msg.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) ->> 分析3
handleMessage(msg);
}
}
/**
* 分析3：handleMessage(msg)
* 注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式
**/
public void handleMessage(Message msg) {
... // 创建Handler实例时复写
}
loop（）内有一个无限for循环，在for循环里，会调用queue的next（）取出当前message，然后在用msg的target调用dispatchMessage（）到对应的handler去，这里的targert本质就是一个handler。
dispatchMessage（）最后会调用handlemessage（）；
message构造：
/**
* 具体使用
*/
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 flag
sPoolSize--;
return m;
}
// 建议：使用obtain（）”创建“消息对象，避免每次都使用new重新分配内存
}
// 若池内无消息对象可复用，则还是用关键字new创建
return new Message();
}
obtain()会优先访问message池，如果池中有mesage实例就拿出来复用，如果没有就调用mesage（）的构造方法。
异步发送message
/**
* 具体使用
*/
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方法 ->>分析3
return 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发送的消息，最终是保存到消息队列->>分析4
return 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()处理消息
sendMesage()经过层层的调用重载最后调用了enqueueMessage（）给msg.target赋值，将message添加到队列中，随后交给looper去循环。最终回调对应handler的handlemessage方法。
思路总结：
post方法源码解析
前面looper和messageQueue的创建和绑定都差不多，主要分析一下不同的地方。
/**
* 具体使用
* 需传入1个Runnable对象、复写run()从而指定UI操作
*/
mHandler.post(new Runnable() {
@Override
public 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方法 ->>分析3
return 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）发送方式相同
post方法将Runnable对象封装成一个message，然后将messageEnQueue的操作和前面一模一样。
- post()和sendMessage()区别在于post无需在外部创建message对象，而是内部根据传入的Runnable对象 封装消息对象，回调的消息处理方法是：复写Runnable对象的run（）。
注意点
Handler必须在有Looper的线程中创建，主线程会自动创建Looper对象，在子线程需要手动调用prepare（）创建，并且调用loop（）循环，当子线程结束时，需要调用quitSafely（）关闭loop循环；
尽量使用obtain（）到Message池中复用Message，在Message被处理后，会调用recycleUnchecked将Message 放到池子里；