Handler是如此的重要
Android是基于消息机制的，比如启动一个Activity，Service，或者结束一个Activity，Service等都是基于ActivityManagerService给ActivityThread发送相应的命令，Hander把这些命令封装为Message，ActivityThread的H（Handler的一个子类）会接收并处理Message，最终ActivityThread会进行相应的Activity或Service的处理，当然广播也包含在内（关于以上分析希望在后面章节进行）。因此Handler在Android的一个应用进程内是一个最基础的服务，它类似于一个大厦的基石，没有它一个应用程序是无法工作的。
它还可以实现进程之间的通信，这个大家肯定都非常熟悉了。
因此我希望把自己对Handler源码的分析记录下来，来对自己学到的知识做一个整理，当然也希望分享出来与大家进行交流，虽然网上关于Handler的各种文章都已经很多了。
生产者/消费者模式
不是说好分析Handler吗？怎么突然插入了这个话题，插入这个话题的主要原因是Handler的消息机制其实就是一个生产者/消费者模式,把这个模式分析下，非常有利于我们来了解Handler。
关于该模式不懂者可以自行百度，用简单一句话来描述该模式：生产者不断的往产品队列里放产品，消费者不断的从产品队列里取产品来进行消费。
关于该模式有几个非常重要核心的点需要关注：
- 消费者，生产者是处于不同的线程的
- 可以有多个消费者，多个生产者
- 队列里的数据需要做到数据同步，数据安全
- 队列没有任何数据时，消费者需要做到处于阻塞状态，同时不会占用系统资源
因此我们从上面几个关注的点来开始进行Handler的源码分析之路
Handler消息机制关键的类
Handler，Message，Looper，MessageQueue，ThreadLocal是Handler消息机制的关键类
生产者/消费者模式来分析下这些类所对应的角色
- Handler的角色既是消费者又是生成者
- Message显而易见它就是产品了
- Looper管理了整个生成/消费环节的不间断进行，开始，结束,可以称之为管理者,一个线程只能拥有自己唯一的Looper
- MessageQueue是产品队列
- ThreadLocal的作用是存储线程自己的Looper实例
那我们就从Looper开始进行分析
Looper生产者/消费者模式管理类
先看段代码
public class MyThread extends Thread{
private Handler mHandler = new Handler();
public void run(){
Looper.prepare();
Looper.loop();
}
}
上面的代码大家肯定很熟悉，为一个线程创建了Looper，这时候其他线程就可以使用mHandler与当前线程通信了
那我们就从Looper.prepare()开始分析，看看它做了啥
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对象,并且把该对象存储在了sThreadLocal中，ThreadLocal与一个Thread是一一对应的关系
在来看Looper.loop()方法
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);
......省略其他代码
}
}
该方法首先取出当前线程的Looper对象，其次在取出Looper对象的MessageQueue对象，也就是我们所说的消息队列，最后创建一个死循环，从queue.next()对象中取出消息，取出消息后交给消息的target即（消费者）进行处理,queue.next()会产生阻塞，这点对应了生产者/消费者模式中当消息队列处于empty状态时，为了不浪费资源而应该处于等待阻塞状态
总结
- 一个
Looper持有一个MessageQueue -
prepare()方法创建一个Looper对象并且把它保存在ThreadLocal中 -
loop()方法开启一个死循环，来不断的从消息队列中读取消息
以上是Looper的几个关键方法和属性
接着分析MessageQueue
MessageQueue
mMessages指向消息队列的头指针，消息队列是使用链表来实现，链表在增加和移动，删除一个节点时性能要优于数组，所以使用链表实现
next()方法：
Message next() {
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
......省略
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
/*阻塞当前线程*/
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
/*target表示没人来处理，因此会阻塞后面的消息处理*/
if (msg != null && msg.target == null) {
/*被阻塞了，查找异步的消息*/
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
/*找到这个消息了*/
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (false) Log.v("MessageQueue", "Returning message: " + msg);
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
......省略
}
上面代码所做的事情是：nativePollOnce最终调用的是native的方法来达到线程的阻塞，nextPollTimeoutMillis ==0代表线程不阻塞,否则线程处于阻塞状态,不阻塞开始从消息队列中取出消息，交给Looper.prepare()来处理，这里也使用了同步锁，保护消息队列数据的安全性和一致性
enqueueMessage方法:
boolean enqueueMessage(Message msg, long when) {
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) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
该方法所做的事情是：生产者把消息放入消息队列中，并且在存放时会查找存放的位置，最终会调用nativeWake(mPtr)的native方法把next() 方法给唤醒，并且该方法加了同步锁的机制，这样可以起到消息队列数据安全同步的效果
总结
当然了上面的方法只是MessageQueue的两个关键方法，其他的方法大家可以自行研究
Message
Message其实就很简单了，它封装了一些数据，既是消息队列的基本单位，也是生产者生产的产品
一般都是通过obtain这个重载方法来创建它的实例，因为这个类很简单，就不多说了，只说一个属性flags,当Message对象已经被放入消息队列中后，该值会被置为FLAG_IN_USE代表它被使用了
既然Message是生产者/消费者中的产品，那我们就来看下它是怎么样被生产者放入消息队列中的
Handler既是生产者又是消费者
我觉得Handler的设计真的是太巧妙了既是Message的生产者又是Message的消费者，这种简单的设计让使用者关心的细节就少了很多，代码写起来也很简单，那就来分析下它吧
Handler h = new Handler();
我们一般在Activity或别的地方new一个Handler是这样写的，当然了也有别的new的方式，上面的代码处于哪个线程，那该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;
}
mLooper = Looper.myLooper()这行代码最终会从ThreadLocal中找到当前Thread的Looper对象,因为Looper对象是在当前线程中一直处于循环运行状态，因此Handler也属于当前线程
mQueue = mLooper.mQueue 当前Looper管理的消息队列，这也是Handler的一个属性，既然持有消息队列，那自然而然的就可以往消息队列中添加消息
那我们就来分析下Handler是怎么样既是生产者又是消费者的
Handler是生产者
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
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);
}
说白了Handler其实最终调用的是MessageQueue对象的enqueueMessage方法，把Message加入消息队列的
Handler是消费者
Looper.loop()方法在收到一个Message后，就会调用Message所对应的target即一个Handler的dispatchMessage方法，把消息分发给消费者处理
关于Handler就总结到次，因为确实很简单
总结
以一张图来总结下Handler的消息机制
