一、消息机制概述
1.消息机制的简介
（1）Handler是什么
handler使Android给我们提供的用来更新UI的一套机制，也是一套消息处理机制；我们可以用它发送处理消息。
（2）Android为什么设计只能通过handler机制来更新ui？
最根本问题使解决多线程并发问题。假设一个activity由多个线程去更新UI，并且都没有加锁机制，那么会造成更新界面错乱。如果都加锁则会造成性能下降；
（3）在子线程中，进行耗时操作，执行完操作后，发送消息，通知主线程更新UI。这便是消息机制的典型应用场景。我们通常只会接触到Handler和Message来完成消息机制，其实内部还有两大助手来共同完成消息传递。
2.消息机制的模型
消息机制主要包含：MessageQueue，Handler和Looper这三大部分，以及Message，下面我们一一介绍。
Message：需要传递的消息，可以传递数据；
MessageQueue：消息队列，但是它的内部实现并不是用的队列，实际上是通过一个单链表的数据结构来维护消息列表，因为单链表在插入和删除上比较有优势。主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；
Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；
Looper：不断循环执行(Looper.loop)，从MessageQueue中读取消息，按分发机制将消息分发给目标处理者。
3.消息机制的架构
（1）消息机制的运行流程：在子线程执行完耗时操作，当Handler发送消息时，将会调用MessageQueue.enqueueMessage，向消息队列中添加消息。当通过Looper.loop开启循环后，会不断地从线程池中读取消息，即调用MessageQueue.next，然后调用目标Handler（即发送该消息的Handler）的dispatchMessage方法传递消息，然后返回到Handler所在线程，目标Handler收到消息，调用handleMessage方法，接收消息，处理消息。
（2）MessageQueue，Handler和Looper三者之间的关系：每个线程中只能存在一个Looper，Looper是保存在ThreadLocal中的。主线程（UI线程）已经创建了一个Looper，所以在主线程中不需要再创建Looper，但是在其他线程中需要创建Looper。每个线程中可以有多个Handler，即一个Looper可以处理来自多个Handler的消息。 Looper中维护一个MessageQueue，来维护消息队列，消息队列中的Message可以来自不同的Handler。
从中我们可以看出：
Looper有一个MessageQueue消息队列；
MessageQueue有一组待处理的Message；
Message中记录发送和处理消息的Handler；
Handler中有Looper和MessageQueue。
二、消息机制的源码解析
1.Looper
UI线程的消息循环是在ActivityThread中的main()方法中创建的，该函数是Android应用程序的入口，代码如下所示：
public static void main(String[] args) { //代码省略 Process.setArgV0("<pre-initialized>"); Looper.prepareMainLooper();//创建Looper ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler();//UI线程的Handler } //代码省略 Looper.loop();//执行消息循环 throw new RuntimeException("Main thread loop unexpectedly exited"); }
其中prepareMainLooper()方法会调用prepare(false)方法。
无参情况下，默认调用prepare(true);表示的是这个Looper可以退出，而对于false的情况则表示当前Looper不可以退出。。
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)); }
这里看出，不能重复创建Looper，只能创建一个。创建Looper,并保存在ThreadLocal。其中ThreadLocal是线程本地存储区（Thread Local Storage，简称为TLS），每个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。
开启Looper
public static void loop() { final Looper me = myLooper(); //获取TLS存储的Looper对象 if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } final MessageQueue queue = me.mQueue; //1.获取Looper对象中的消息队列 Binder.clearCallingIdentity(); final long ident = Binder.clearCallingIdentity(); for (;;) { //2.进入loop的主循环方法（即消息循环） Message msg = queue.next(); //3.可能会阻塞,因为next()方法可能会无限循环 if (msg == null) { //消息为空，则退出循环 return; } Printer logging = me.mLogging; //默认为null，可通过setMessageLogging()方法来指定输出，用于debug功能 if (logging != null) { logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); } msg.target.dispatchMessage(msg); //4.获取msg的目标Handler，然后用于分发Message （处理消息） if (logging != null) { logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); } final long newIdent = Binder.clearCallingIdentity(); if (ident != newIdent) { } msg.recycleUnchecked(); } }
loop()实质上进入循环模式，不断重复从消息队列中逐个取出消息，最后处理消息的过程（如下描述），直到消息为空时退出循环:
循环过程：
- 读取MessageQueue的下一条Message（关于next()，后面详细介绍）；
- 把Message分发给相应的target。
当next()取出下一条消息时，队列中已经没有消息时，next()会无限循环，产生阻塞。等待MessageQueue中加入消息，然后重新唤醒。
Looper总结：通过Looper.prepare()来创建Looper对象（消息队列封装再Looper对象中），并且保存在sThreadLocal中，然后通过Looper.loop()来执行消息循环，这两步通常是成对出现的。
2.Handler
在子线程完成耗时操作后，如果需要更新ui，最常用的方法就是通过HAndler将一个消息post大盘UI线程中，然后再在Handler的handlerMessage方法中进行处理，需要注意的是，该Handler必须在主线程中创建。
class MyHandler extends Handler{ @Override public void handleMessage(Message msg) { //更新UI } } MyHandler myHandler = new MyHandler(); //开启新线程 new Thread(){ @Override public void run() { myHandler.sendEmptyMessage(123); } }.start();
每个Handler都会关联一个消息队列，消息队列被封装在Looper中，而每个Looper会关联一个线程（Looper通过ThreadLocal封装），最终就等于每个消息队列会关联一个线程。Handler就是一个消息处理器，将消息投递给消息队列，然后再由对应的线程的从消息队列中诸葛取出消息，并且执行。默认情况下，消息队列只有一个，即主线程的消息队列。那么Handler如何关联消息队列以及线程的呢？
public Handler() { this(null, false); } public Handler(Callback callback, boolean async) { ................................. //必须先执行Looper.prepare()，才能获取Looper对象，否则为null. mLooper = Looper.myLooper(); //从当前线程的TLS中获取Looper对象 if (mLooper == null) { throw new RuntimeException(""); } mQueue = mLooper.mQueue; //消息队列，来自Looper对象 mCallback = callback; //回调方法 mAsynchronous = async; //设置消息是否为异步处理方式 }
对于Handler的无参构造方法，通过Looper.myLooper()方法，默认采用当前线程TLS中的Looper对象，并且callback回调方法为null，且消息为同步处理方式。只要执行的Looper.prepare()方法，那么便可以获取有效的Looper对象。那么Looper.myLooper()怎么工作的：
public static @Nullable Looper myLooper() { return sThreadLocal.get(); } ......................... //设置UI线程的Looper 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 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)); }
从上述代码可以看出myLooper()是从sThreadLocal.get()获取的。而存储在prepare()方法完成。这样一来不同线程就不能访问对方的消息队列。
再回到Handler中来，消息队列通过Looper与线程关联上，而Handler又与Looper关联，因此Handler最终就和线程、线程的消息队列关联上了。这就解释了”为什么要更新UI的Handler必须再主线程中创建？“。就是因为Handler要与主线程的消息队列关联上，这样handlerMessage才会再UI线程执行，此时更新UI才是线程安全的。
3.发送消息
(1) Message
先看一下Message的源码：
public final class Message implements Parcelable{ public int what; public int arg1; public int arg2; public Object obj; public Messenger replyTo; /*package*/ int flags; /*package*/ long when; /*package*/ Bundle data; /*package*/ Handler target;//target处理 /*package*/ Runnable callback;//Runnable类型的callback // sometimes we store linked lists of these things /*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; }
- what：用户定义消息代码以便收件人可以识别这是哪一个Message。每个Handler用它自己的名称空间为消息代码,所以您不需要担心你的Handler与其他handler冲突。
- arg1、arg2：如果只是想向message内放一些整数值，可以使用arg1和arg2来代替setData方法。
- obj：发送给接收器的任意对象。当使用Message对象在线程间传递消息时，如果它包含一个Parcelable的结构类（不是由应用程序实现的类），此字段必须为非空（non-null）。其他的数据传输则使用setData(Bundle)方法。注意Parcelable对象是从FROYO版本以后才开始支持的。
- replyTo：指明此message发送到何处的可选Messenger对象。具体的使用方法由发送者和接受者决定。
ps：new Message和obtain的有什么区别：https://blog.csdn.net/dfskhgalshgkajghljgh/article/details/52672115
发送消息有几种方式，但是归根结底都是调用了sendMessageAtTime()方法。
在子线程中通过Handler的post()方式或send()方式发送消息，最终都是调用了sendMessageAtTime()方法。
（2）post方法
public final boolean post(Runnable r) { return sendMessageDelayed(getPostMessage(r), 0); } public final boolean postAtTime(Runnable r, long uptimeMillis) { return sendMessageAtTime(getPostMessage(r), uptimeMillis); } public final boolean postAtTime(Runnable r, Object token, long uptimeMillis) { return sendMessageAtTime(getPostMessage(r, token), uptimeMillis); } public final boolean postDelayed(Runnable r, long delayMillis) { return sendMessageDelayed(getPostMessage(r), delayMillis); }
在post(Runnable r)时，会将Runnable包装成Message对象，并且将Runnable对象设置给Message对象的callback字段，最后将该Message对象插入到消息队列
（3）send方法
public final boolean sendMessage(Message msg) { return sendMessageDelayed(msg, 0); } public final boolean sendEmptyMessage(int what) { return sendEmptyMessageDelayed(what, 0); } public final boolean sendEmptyMessageDelayed(int what, long delayMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageDelayed(msg, delayMillis); } public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageAtTime(msg, uptimeMillis); } public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); }
就连子线程中调用Activity中的runOnUiThread()中更新UI，其实也是发送消息通知主线程更新UI，最终也会调用sendMessageAtTime()方法。
public final void runOnUiThread(Runnable action) { if (Thread.currentThread() != mUiThread) { mHandler.post(action); } else { action.run(); } }
如果当前的线程不等于UI线程(主线程)，就去调用Handler的post()方法，最终会调用sendMessageAtTime()方法。否则就直接调用Runnable对象的run()方法。
下面我们就来一探究竟，到底sendMessageAtTime()方法有什么作用？
sendMessageAtTime()
public boolean sendMessageAtTime(Message msg, long uptimeMillis) { //其中mQueue是消息队列，从Looper中获取的 MessageQueue queue = mQueue; if (queue == null) { RuntimeException e = new RuntimeException( this + " sendMessageAtTime() called with no mQueue"); Log.w("Looper", e.getMessage(), e); return false; } //调用enqueueMessage方法 return enqueueMessage(queue, msg, uptimeMillis); }
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } //调用MessageQueue的enqueueMessage方法 return queue.enqueueMessage(msg, uptimeMillis); }
可以看到sendMessageAtTime()`方法的作用很简单，就是调用MessageQueue的enqueueMessage()方法，往消息队列中添加一个消息。
下面来看enqueueMessage()方法的具体执行逻辑。
enqueueMessage()
boolean enqueueMessage(Message msg, long when) { // 每一个Message必须有一个target if (msg.target == null) { throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) { if (mQuitting) { //正在退出时，回收msg，加入到消息池 msg.recycle(); return false; } msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { //p为null(代表MessageQueue没有消息） 或者msg的触发时间是队列中最早的， 则进入该该分支 msg.next = p; mMessages = msg; needWake = mBlocked; } else { //将消息按时间顺序插入到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; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; prev.next = msg; } if (needWake) { nativeWake(mPtr); } } return true; }
MessageQueue是按照Message触发时间的先后顺序排列的，队头的消息是将要最早触发的消息。当有消息需要加入消息队列时，会从队列头开始遍历，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序。
4.获取消息
当发送了消息后，在MessageQueue维护了消息队列，然后在Looper中通过loop()方法，不断地获取消息。上面对loop()方法进行了介绍，其中最重要的是调用了queue.next()方法,通过该方法来提取下一条信息。下面我们来看一下next()方法的具体流程。
next()
Message next() { final long ptr = mPtr; if (ptr == 0) { //当消息循环已经退出，则直接返回 return null; } int pendingIdleHandlerCount = -1; // 循环迭代的首次为-1 int nextPollTimeoutMillis = 0; for (;;) { if (nextPollTimeoutMillis != 0) { Binder.flushPendingCommands(); } //阻塞操作，当等待nextPollTimeoutMillis时长，或者消息队列被唤醒，都会返回 nativePollOnce(ptr, nextPollTimeoutMillis); synchronized (this) { final long now = SystemClock.uptimeMillis(); Message prevMsg = null; Message msg = mMessages; if (msg != null && msg.target == null) { //当消息Handler为空时，查询MessageQueue中的下一条异步消息msg，为空则退出循环。 do { prevMsg = msg; msg = msg.next; } while (msg != null && !msg.isAsynchronous()); } 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; //设置消息的使用状态，即flags |= FLAG_IN_USE msg.markInUse(); return msg; //成功地获取MessageQueue中的下一条即将要执行的消息 } } else { //没有消息 nextPollTimeoutMillis = -1; } //消息正在退出，返回null if (mQuitting) { dispose(); return null; } ............................... } }
nativePollOnce是阻塞操作，其中nextPollTimeoutMillis代表下一个消息到来前，还需要等待的时长；当nextPollTimeoutMillis = -1时，表示消息队列中无消息，会一直等待下去。
可以看出next()方法根据消息的触发时间，获取下一条需要执行的消息,队列中消息为空时，则会进行阻塞操作。
5.分发消息
在loop()方法中，获取到下一条消息后，执行msg.target.dispatchMessage(msg)，来分发消息到目标Handler对象。
下面就来具体看下dispatchMessage(msg)方法的执行流程。
从源码中可以看出，target是Handler类型，实际上就是转了一圈，通过Handler将消息投递给消息队列，消息队列又传给Handler来处理，继续看：
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) { message.callback.run(); }
分发消息流程：
从上述程序可以看出，dispatchMessage只是一个分发的方法
当Message的msg.callback不为空时，则回调方法msg.callback.run();
当Handler的mCallback不为空时，则回调方法mCallback.handleMessage(msg)；
最后调用Handler自身的回调方法handleMessage()，该方法默认为空，Handler子类通过覆写该方法来完成具体的逻辑。
threadHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() { @Override public boolean handleMessage(Message msg) { //dosomething... return true;//1.true则不走handler的handleMessage；false则走 } }) { @Override public void handleMessage(Message msg) { Log.d("handlerThreadActivity", handlerThread.getName() + ""); } };
消息分发的优先级：
Message的回调方法：message.callback.run()，优先级最高；
Handler中Callback的回调方法：Handler.mCallback.handleMessage(msg)，优先级仅次于1；
Handler的默认方法：Handler.handleMessage(msg)，优先级最低。
对于很多情况下，消息分发后的处理方法是第3种情况，即Handler.handleMessage()，一般地往往通过覆写该方法从而实现自己的业务逻辑。
三、总结
以上便是消息机制的原理，以及从源码角度来解析消息机制的运行过程。可以简单地用下图来理解。
