本篇提纲.png
一.Looper、Handler、MessageQueue与Message的关系与相关概念
1.什么是Android消息处理机制？
“消息”是windows运行机制中一个基本而又重要的概念。消息是一个报告事件发生的通知，消息驱动是围绕消息的产生与处理展开的，并依靠消息循环机制来实现（百度百科）。与Windows系统一样，Android也是消息驱动型的系统。引用一下消息驱动机制的四要素：
①接收消息的“消息队列”
②阻塞式地从消息队列中接收消息并进行处理的“线程”
③可发送的“消息的格式”
④“消息发送函数”
与之对应，Android系统中对应实现了：
①接收消息的“消息队列” —— MessageQueue
②阻塞式地从消息队列中接收消息并进行处理的“线程” —— Thread+Looper
③可发送的“消息的格式” —— Message
④“消息发送函数”—— Handler的post()和sendMessage()
Android有大量的消息驱动方式来进行交互，比如Android的四大组件——Activity, Service, Broadcast, ContentProvider的启动过程的交互，都离不开消息机制。
2.Handler
Android的消息机制，很多时候我们也称之为“Handler机制”，可见Handler这个东西是相当重要了～～那么Handler是用来干什么的呢？刚刚笔者在刷知乎的时候看到有大神怼(教导)一个Android菜鸟的时候其中就提到了一点“...以为Handler就是用来更新UI的...”——好吧，真是垂死病中惊坐起——开始学Android那会笔者也曾经这么认为(捂脸)。
如果你也这么认为，那么从今天起你就要放弃这种狭隘的想法——Handler是Android消息机制的上层接口，因此我们在开发中与Handler打交道的机会最多。Handler并不是专门用来更新UI的，只是开发者常常用它来更新UI。Handler的主要用于同一个进程间的线程通信，Handler用于更新UI的时候是"子线程与主线程通信"；当然，Handler也可以用于子线程之间通信。
Handler的消息机制主要是就指“Handler的运行机制”，Handler的运行机制时需要底层的MessageQueue和Looper支持的。
3.MessageQueue
MessageQueue翻译过来是"消息队列"的意思，实际上它内部的数据结构不是队列，而是单向链表；MessageQueue中储存了大量的消息，由于一个线程同一时间只能处理一条消息，所以我们建了一个链表，将我们需要处理的消息按顺序储存起来，然后一项一项的交给需要的线程处理，这就是MessageQueue存在的价值。
这里笔者想到一个问题——为什么MessageQueue要用链表而不用数组来作为数据结构呢？再经过网上查找博客＋源码阅读，笔者认为是这样的——之前我们在一片文章中有讲过，单链表更适合做增删的操作，数组更适合做随机访问的操作。再MessageQueue中，我们不止要做随机访问(这里不是真的随机访问，消息的读取是根据计算出来的时间顺序来的，后文会讲)跟多的我们做的是插入和删除操作，MessageQueue.enqueueMessage()就是插入消息(消息的插入需要根据时间发送的时间顺序来确定，不存在头插还是尾插)，而插入消息；而MessageQueue.next()则是读取消息，且读取的同时也伴随这删除的过程。试想一下，一个消息队列要循环起来，必然要频繁的进行插入/读取操作，假如采用数组的话，这两个操作的平均时间复杂度都是O(N/2)，而链表为O(1)，显然链表更合适。
4.Looper
Looper和MessageQueue的消息就像水泵和井(里边装的是水)的关系一样，我们有了消息(水)，但是为了把水从井中抽取出来(循环起来)，我们得有一个水泵作为动力，这个动力就是Looper。
如果我们在一个线程中调用Looper.prepare()...Looper.loop()，那么你的线程就成功升级为了一个Looper线程，这意味着你的线程有了一个消息泵(Looper)和一个消息队列(MessageQueue),此时你就可以调用Handler来进行线程间的通信了。
我们应用的UI线程也就是主线程，在应用启动的时候，系统会自动初始化一个Looper，也就是说，我们的UI线程默认是Looper线程。这也就是为什么主线程中直接调用Handler没什么事，但是再子线程中创建Handler需要哦手动调用Looper.prepare()...Looper.loop()的和原因。
5.Message
Message也就是消息，井中的水。一个Message包括了消息类型(what),消息内容(arg1,arg2),发送它的Handler(target),Runnable回调接口等：
public int what; //数据类型
public int arg1; //简单的整数值
public int arg2; //简单的整数值可以直接发送，是一种替代setData（Bundle）的低成本方案，更加省资源
public Object obj;
......
/*package*/ int flags;
/*package*/ long when; //Handler发送一个消息之后，返回此消息的目标交付时间（以毫秒为单位）。
/*package*/ Bundle data; //Bundle可以携带更复杂的数据类型
/*package*/ Handler target; //哪个Handler发送的消息
/*package*/ Runnable callback;
//可以看到，Message带了一个指向一下个节点的链，也就是说，MessageQueue内部维护的实际上是一个链表
/*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; //消息池的最大容量
讲到这里，我们先上一张图加深一下大家对于这几个东西的直观认识：
Handler循环机制.png
二.子线程与主线程Handler通信原理(子线程是如何通过Handler更新UI的)
1.一些熟悉的场景
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) { //判断标志位
case 1:
//更新UI操作
break;
}
}
};
public class MyThread extends Thread {
@Override
public void run() {
super.run();
//耗时操作
｝
Message msg =Message.obtain();//从全局池中返回一个message实例，避免多次创建（如new Message）
msg.obj = data;
msg.what=1; //标志消息的标志
handler.sendMessage(msg);
}
new MyThread().start();
上面代码是我们再Android开发中经常写的一段代码，其主要作用是再子线程中进行耗时操作，并通过Handler向主线程中发送消息，通知主线程做出相应的UI变化。注意这段代码中，Handler是再主线程中创建的，因此不需要手动调用Looper.prepare()添加Looper。
如果我们试图再子线程中创建一个Handler，如:
Handler handler ;
public class MyThread extends Thread {
@Override
public void run() {
super.run();
//耗时操作
｝
handler = new Handler();
Message msg =Message.obtain();//从全局池中返回一个message实例，避免多次创建（如new Message）
msg.obj = data;
msg.what=1; //标志消息的标志
handler.sendMessage(msg);
}
new MyThread().start();
那么很显然，这个时候就会出bug了～～为了解决这个bug，我们需要手动再子线程中创建Looper：
handler = new Handler();
Looper.prepare();
Message msg =Message.obtain();//从全局池中返回一个message实例，避免多次创建（如new Message）
msg.obj = data;
msg.what=1; //标志消息的标志
handler.sendMessage(msg);
Looper.loop();
为什么是这样呢？接下来从源码的解读分析
2.Looper
(frameworks/base/core/java/android/os/Looper)
(1)Looper.perpare()
public final class Looper {
private static final String TAG = "Looper";
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal sThreadLocal = new ThreadLocal();
private static Looper sMainLooper; // guarded by Looper.class
final MessageQueue mQueue;
final Thread mThread;
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));
}
......
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
}
首先我们看到Looper.prepare()方法中调用了prepare(ture)方法，其中true表示，该Looper是可以被终止的。因为我们是在子线程中创建的Looper，当子线程的消息处理完之后，理应把改Looper终止掉(MessageQueue.quit)。但是在主线程的Looper中:
public static void prepareMainLooper() {
prepare(false);
......
}
prepareMainLooper就是给主线程添加Looper,可以看到，主线程中的prepare(false)中的参数false表示的是，主线程中的Looper不能被终止掉，毕竟它是整个应用的生命，需要时刻准备着处理或者正在处理应用中的各种消息。
好了我们接着看上面的prepare()中干了什么。这里出现了一个新的重量级的东西：sThreadLocal，它是ThreadLocal类的实例，关于ThreadLocal类是干什么的，我们在这里不做过多解释，我们只需要知道他是用于储存不同线程唯一对象的一个东西,即多个线程在ThreadLocal类中，通过ThreadLocal.set()保存了自己的变量之后，那么我们再各个子线程中调用ThreadLocal.get()方法，得到的仍然是当前线程之前存进去的那个值。各个线程存取各自的值，不会产生冲突。
知道了ThreadLocal的作用之后，我们在来看sThreadLocal.set(new Looper(quitAllowed));这句表示我们再ThreadLocal类中保存了一个Looper对象(new Looper())，根据上面对ThreadLocal类的介绍，如果我们再当前线程中调用ThreadLocal.get()方法，则会得到本线程之前保存的唯一的变量。因此：
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
这个if表示的是，如果sThreadLocal.get() != null，说明当前线程中已经存在一个Looper，我们不能在一个线程中同时创建多个，所以此时会抛出异常。为了避免这种异常，我们可以在Looper.prepare()之前调用Looper.myLooper()类来返回当前线程中的Looper对象，判断为空之后，再调用prepare()：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
Ok，比比了这么多，我们接着看new Looper()中Looper中的构造函数中做了什么:
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
这里出现了消息队列MessageQueue(quitAllowed)，其中参数就是表示是否允许Looper退出的标示符。可以看到，在Looper中我们创建了一个MessageQueue实例：
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
```
，此时我们的Looper就拥有了MessageQueue的对象引用。
###### (2)Looper.Loop()
在Looper.perpare()调用完即我们为线程准备好Looper之后，最后一步我们还需要调用Loop()让整个Looper循环起来，这样消息才能发送出去:
```
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
......
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
......
msg.target.dispatchMessage(msg);
......
msg.recycleUnchecked(); //释放占据的资源
}
}
```
首先调用了我们刚说过的myLooper()来获取当前线程再ThreadLcoal类中储存的Looper,如果Looper为空则会抛出异常，提示当前线程没有Looper。然后`inal MessageQueue queue = me.mQueue;`是获取当前线程的Looper中的MessageQueue对象。
之后这个Looper便进入了一个无限循环的状态——for(;;)，`Message msg = queue.next();`是一条一条遍历整个消息队列，拿出msg消息。
而`msg.target.dispatchMessage(msg);`这句中的**msg.target**实际上就是当前消息的目标Handler，也就是**哪个线程中的Handler发送的消息，当然，这个发送它的Handler也要在自己所在的线程中接受这条消息。**
`msg.recycleUnchecked();`这句是将这天消息放入Message类中的消息池中。
从上面我们基本上可以得出——**Looper > MessageQueue > Message**的关系，也就是说，**每个Looper中维护了一个消息队列，而一个消息队列中则以链表的形式排列着一条条消息。**
##### 3.MessageQueue.next()
(frameworks/base/core/java/android/os/MessageQueue)
上面的Looper类中我们实例化了一个MessageQueue对象，并调用了MessageQueue.next()类方法:
```
Message next() {
final long ptr = mPtr; //当消息循环已经退出，则直接返回
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration 循环迭代的首次为-1，也就是初始值为-１
int nextPollTimeoutMillis = 0;
for (;;) { //消息队列开始无限循环
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//阻塞操作的方法，当等待nextPollTimeoutMillis时长，或者消息队列里边有了消息被唤醒时，
//只有满足这两个条件该方法才会返回，for循环才能往下执行下面的代码，否则就一直在这等着
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) { //这一段同步块代码中就是再检索下一条message,如果找到了就返回
final long now = SystemClock.uptimeMillis(); //手机开机到现在的时间(毫秒为单位)，手机睡眠的时间不包括再内
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
do { //如果此时消息不为null,但是这个消息找不到发送它的Handler，说明为不合法消息，放弃并寻找下一条异步消息
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) { //如果消息不为null(这次是个正常消息)
if (now < msg.when) {
// 虽然消息是正常的，但是还没到发送的时间。msg.when表示消息发送的时间，因为我们可能调用了postDelay()
//延迟发送。我们之前说过，当等待nextPollTimeoutMillis时长后nativePollOnce()方法就会返回。
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else { //else则表示，成功抓到了一条消息
mBlocked = false;
if (prevMsg != null) { //单链表操作，下面讲
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse();
return msg;
}
} else {
nextPollTimeoutMillis = -1;
}
......
}
......
}
}
```
首先:
```
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
```
这个mPtr我们之前在MessageQueue的构造方法中提到过:
```
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
```
它通过` mPtr = nativeInit();`得到值，`nativeInit()`是一个native层的方法，根据注释来看，它主要是判断Looper目前的状态。`if (ptr == 0) {`表示的是当前线程的Looper已经退出或者被处理掉了，这种情况发生在“应用在退出之后试图重启Looper”的情况下，这种情况是不被允许的，因此此时`return null;`
上面这段中还要讲的就是单链表的操作:
```
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse(); //表示这个消息已经被传递(使用了)
return msg;
}
```
首先，再synchronized (this)同步块一开始的时候，有一个**全局变量mMessages，这实际上就是等待处理消息**,这个变量很重要，之后我们会多次遇到。这里还有一个叫prevMsg的Message,用于保存找不到msg.target的消息(废消息)。OK，回到链表操作中来，`if (prevMsg != null)`，很遗憾，有一个不合法的消息，此时上面已经经历了`prevMsg = msg; msg = msg.next;`这两步，加上`prevMsg.next = msg.next;`这一步，实际上就是prevMsg的后继引用跳过了msg，直接指向了msg的下一位(注意prevMsg是不合法的，但是它的下一位msg是合法的)。
再看else，说明没有不合法的消息，`Message msg = mMessages;`加上`mMessages = msg.next;`，这两步实际上和上面一样，也是工作指针后移，越过了msg。**也就是msg出队，msg的下一条消息成为mMessages(待处理消息)，否则就进入一个阻塞状态，一直等到有新的消息入队。**
OK，上面if和else中越过的msg，就是我们要返回的正常消息，接着两句:`msg.next = null;`和`return msg;`就可以知道，前者是将msg的后继引用清空(将它从链表中删除)，然后return。
通过上面的分析我们知道，**MessageQueue.next()作用就是遍历链表，找出一个合法的msg，将它从链表中删除后返回**，这实际上也就是一个**消息出队**的过程
##### 4.Handler
###### (1)Handler.post/sendMessage将一个消息添加到消息队列中
上面我们已经讲完了Handler通信的两个重要的基础类——**MessageQueue**和**Looper**，接下来我们分析一下Handler是如何将一个消息发送出去的。
我们从Handler的构造函数开始看起：
```
public Handler() {
this(null, false);
}
......
public Handler(Callback callback, boolean async) {
......
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
```
可以看到，Hnadler在发送消息的时候先获取当前线程的Looper，然后做一次looper的非空判断；接着获取了Looper中的MessageQueue对象。这样，我们的Handler已经和Looer以及MessageQueue取得了联系。
接着回到文章最开始的时候举的那个例子中，handler.sendMessage()方法:
```
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
```
上面几个方法的逻辑都比较清晰，可以看到，最终调用了MessageQueue的enqueueMessage()方法，其中第一个参数为msg,第二个参数**uptimeMillis = SystemClock.uptimeMillis() + delayMillis**，也就是**开机到现在的时间(不包括睡眠时间)+我们设定的delay时间**，接下来我们看看enqueueMessage()方法:
```
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) { //目标Handler为null
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) { //msg已经用过了
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) { //如果这个Looper正在退出，回收msg，加入到消息池
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
msg.recycle(); //释放msg资源
return false;
}
msg.markInUse(); //表示这个msg已经被使用了
//这里我们可以知道，Message类的when属性实际上就是SystemClock.uptimeMillis() + delayMillis
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
//如果p == null，说明MessageQueue中没有消息；或者msg的时间是这个消息队列中最靠前的
msg.next = p; //将这个msg提取出来，并复制给mMessages，mMessages会在上面的
mMessages = msg; //MessageQueue.next()方法中进行一系列判断后返回
needWake = mBlocked; //当阻塞时需要唤醒
} else { //elss,说明此时我们发送过来的消息需要按照一定规则插入到队列中
//将消息按时间顺序插入到MessageQueue。一般地，不需要唤醒事件队列，除非
//消息队头存在barrier，并且同时Message是队列中最早的异步消息。
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
① for (;;) {
prev = p;
p = p.next; //工作指针后移并且循环遍历链表
if (p == null || when < p.when) { //找到一个不为空并且发送时间大于当前发送时间的消息,
break; //跳出循环，准备把msg（要发送的消息）查到这条消息之前
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
② msg.next = p; // 单链表插入
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
```
MessageQueue是按照**Message触发时间的先后顺序**排列的，队头的消息是将要最早触发的消息。当有消息需要加入消息队列时，会**从队列头开始遍历**，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序。
上面代码中①处的for()循环就是在循环遍历MessageQueue以找到合适的msg插位置，②处的代码实际上就是一个单链表插入的过程，我们可以把整个插入的代码连起来，这样更容易看出:
```
prev = p;
p = p.next;
msg.next = p;
prev.next = msg;
```
没骗你吧~~这就是把我们的要发送的消息msg插入到了链表中的p节点之前。
**我们需要明确的一点是，这里的Handler.post/sendMessage方法是和上面的MessageQueue.next()方法是对应的，他是消息的入队操作。**
###### (2)Looper.loop()中调用Handler.dispatchMessage()接受并处理消息
好了，讲到这里，我们可以看到，Handler.post或者Handler.sendMessage方法，最终是将他们要发送的消息添加到了消息队列中(Handler.post实际上也是调用了Handler.sendMessageDaley())。
那么接受消息在哪呢？好吧看标题你也知道，Looper.loop()方法中我们实现了消息的重写与接收。我们回过头去看Looper类，在该类中MessageQueue.next()这个消息出队的方法调用完之后，出现了`msg.target.dispatchMessage(msg);`这句代码，我们说过这句代码中的**msg.target**就是消息的目标Handler,于是我们回到Handler中看下这个方法:
```
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
```
可以看到最终我们调用了一个空方法，为什么呢，因为**消息的最终回调是由我们控制的**，我们在创建handler的时候会在Handler所在的线程中(如果是子线程更新主线程UI的话，就在主线程中)重写handleMessage方法，然后根据msg.what进行消息处理(对照开始给出的Hanlder常见场景)。
我们梳理一下整个流程:
```
① handler = new Handler(); //创建Handler对象
② Looper.prepare(); //准备好Looper，初始化MessageQueue
③ Message msg =Message.obtain(); //从消息池中取出一个可用的Message实例
④ msg.obj = data; //消息的数据
msg.what=1; //标志消息的标志
⑤ handler.sendMessage(msg); //发送消息，将一个消息添加到消息队列中去
⑥ Looper.loop(); //使用loop使消息队列循环起来，并进行消息的出队删除操作
```
Looper.loop()中的消息出队之后，将调用Handler的dispatchMessage，最终大我们在代码中重写的handleMessage用以自定处理：
```
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) { //判断标志位
case 1:
//更新UI操作
break;
}
}
};
```
###### (3)Handler.post() & View.post() & Activity.runOnUiThread()
**①Handler.post()**
上面我们说了Handler.sendMessage()方法，并且在文章开头的实例中展示了Handler.sendMessage()的使用方法，下面我们来说一下Handler.post()，该方法的具体使用还是略微的有一点不同的:
```
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
```
可以看到，Hander.post()方法还是调用了sendMessageDelayed方法，这跟之前的流程是一样的。这里我们要说的是`sendMessageDelayed(getPostMessage(r), 0);`中的getPostMessage(r)方法:
```
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
```
在这个方法中将消息的callback字段的值指定为传入的Runnable对象。这个callback字段之前我们有遇到过——在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法：
```
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
```
handleCallback(msg)：
```
private static void handleCallback(Message message) {
message.callback.run();
}
```
这里的run也就是一开始的时候传入的run接口。也就是说，如果通过post(Runnable r)传递消息的话，我们直接就可以在post()方法中进行UI操作:
```
handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
handler.post(new Runnable() {
@Override
public void run() {
// 在这里进行UI操作
}
});
}
}).start();
```
写法上简洁了很多，但是本质上都是一样的。
**②View.post()**
(source/android-24/android/view/View):
```
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
// Postpone the runnable until we know on which thread it needs to run.
// Assume that the runnable will be successfully placed after attach.
getRunQueue().post(action);
return true;
}
```
可以看到同样调用了Handler的post方法
**Activity.runOnUiThread()**
```
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}
```
如果当前的线程不等于UI线程(主线程)，就去调用Handler的post()方法，否则就直接调用Runnable对象的run()方法。
##### 5.Message.obtain
上面我们需要解释的一个东西便是`Message msg =Message.obtain();`这句，Message的obtain()方法中维护了一个消息池，其最大容量**MAX_POOL_SIZE = 50**
```
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) { //消息池不为空时从消息池中直接拿消息
Message m = sPool;
sPool = m.next; //工作指针后移，准备取出sPool
m.next = null; //从sPool中取出一个Message对象，并消息链表断开
m.flags = 0; // 清除in-use flag
sPoolSize--; //消息池的可用大小进行减1操作
return m;
}
}
return new Message(); // 当消息池为空时，直接创建Message对象
}
/** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
*/
public Message() {
}
```
我们当然可以直接new Message()这样来创建消息，但是一般来讲我们还是应该调用Message.obtain()方法来返回一个消息实例，以避免Message对象的多次创建。
好了，到此为止，我们调用Handler发送消息更新UI的整个流程就说完了。
#### 三.Activity启动过程中UI线程的MainLooper的创建
Actvity的启动流程我们之前在一片文章中有讲过，真正启动Activity的是ActiivtyThread类中的main()方法：
```
public static void main(String[] args) {
......
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
......
Looper.loop();
......
}
```
可以看到，我们在启动一个Activity之前,我们在ActivityThread.main()方法中，调用了**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();
}
}
```
该方法同上面的Looper.prepare()方法一样，只不过这里准备的是主线程中的Looper,因此**prepare(false);**其中的参数false表示的是，该线程的Looper不能退出。之后调用myLooper则是获取主线程中的Looper对象，这些和上面都没什么区别。
我们回到ActivityThread.main()中，在准备完主线程的Looper之后，`ActivityThread thread = new ActivityThread();`创建一个ActivityThread实例。`thread.attach(false);`**参数false表示这不是系统进程，是给普通应用程序使用的进程。**
我们接着`thread.attach(false);`来看：
```
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
ViewRootImpl.addFirstDrawHandler(new Runnable() {
@Override
public void run() {
ensureJitEnabled();
}
});
......
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
......
```
注意到`mgr.attachApplication(mAppThread);`这句，其中mAppThread是ApplicationThread的对象，**mgr**为**IActivityManager**接口类，而真正实现IActivityManager接口的是在ActivityManagerService(AMS)类中,关于AMS类中的代码我们这里就先不详细解释了，我们只需要知道，在它当中经过一系列的处理~~最终：
```
app.thread.scheduleLaunchActivity(new Intent(r.intent), r, System.identityHashCode(r),
r.info, r.icicle, results, newIntents, !andResume, isNextTransitionForward());
}
```
又回调到了ActivityThread类中：
```
//该方法在ApplicationThread(Binder线程)中调用
@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List pendingResults, List pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.referrer = referrer;
r.voiceInteractor = voiceInteractor;
r.activityInfo = info;
r.compatInfo = compatInfo;
r.state = state;
r.persistentState = persistentState;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profilerInfo = profilerInfo;
r.overrideConfig = overrideConfig;
updatePendingConfiguration(curConfig);
sendMessage(H.LAUNCH_ACTIVITY, r);
}
```
可以看到，这里将一系列应用的信息封装在ActivityClientRecord中之后，最终调用了`sendMessage(H.LAUNCH_ACTIVITY, r);`发送消息：
```
private void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
```
```
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
```
上面的“H”实际上就是一个Handler类：`private class H extends Handler {`，而这里的mH则是H的子类。接着往下看：
```
public void handleMessage(Message msg) {
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
......
```
可以看到，这里handleMessage收到了我们发送的`LAUNCH_ACTIVITY`也就是启动Activity的请求，实际上这里还有`PAUSE_ACTIVITY`，`RESUME_ACTIVITY`等一系列请求的处理。
之后`handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");`-->`performLaunchActivity`-->`mInstrumentation.callActivityOnCreate`一系列流程之后，我们的Activity就启动了，这个我们在之前的文章中有讲过，这里不再獒述。
给大家展示这一段，主要是为了说明，在Activity的启动过程中，在系统层面也是调用Handler机制来进行一系列事件的处理，从而推动系统的循环进行。
站在巨人的肩膀上摘苹果：
《Android开发艺术探索》
[郭霖 Android异步消息处理机制完全解析，带你从源码的角度彻底理解](http://blog.csdn.net/guolin_blog/article/details/9991569)
[Gityuan Android消息机制1-Handler(Java层)](http://gityuan.com/2015/12/26/handler-message-framework/)