android Handler 源码解析

Handler在开发过程中是经常使用，比如异步线程中加在数据，通过Handler机制刷新UI等等。

下面通过Handler源码来具体分析一下Handler该类的作用。

Handler构造函数：

Handler 有7个构造函数，主要看后面两个

public Handler() {
this(null, false);
}

public Handler(Callback callback) {
this(callback, false);
}

public Handler(Looper looper) {
this(looper, null, false);
}

public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}

public Handler(boolean async) {
this(null, async);
}

public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}

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

该构造函数其内部可以看出，首先是获取当前线程的Looper对象，如果当前Looper对象为null，那么直接抛出异常，如果不为null 则将构造函数中的参数赋值给全局变量。

public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}

同样该构造函数在参数传递上相对于上一个构造函数，是将Looper对象直接通过参数形式通过外部传入，之后将这些传入的参数赋值给全局变量。

在解析完Handler的构造函数之后，接下来解析Handler中常用的方法。

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

public final boolean postAtFrontOfQueue(Runnable r)
{
return sendMessageAtFrontOfQueue(getPostMessage(r));
}

5 个post方法，分别是：post(Runnable r)、postAtTime(Runnable r, long uptimeMillis)、postAtTime(Runnable r, Object token, long uptimeMillis)、postDelayed(Runnable r, long delayMillis)、postAtFrontOfQueue(Runnable r)

而这5个post方法中实质上是执行了 3个 sendMessage方法，分别是：

sendMessageDelayed(getPostMessage(r), 0)、sendMessageAtTime(getPostMessage(r), uptimeMillis)、sendMessageAtFrontOfQueue(getPostMessage(r))

而在Handler中sendMessage方法存在 7个方法，源码分别是：

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

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

public final boolean sendMessageAtFrontOfQueue(Message msg) {
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, 0);
}

仔细观察其实可以看出，前面5个sendMessage()方法最重会执行到sendMessageAtTime(Message msg, long uptimeMillis)

那么注重分析 sendMessageAtTime(Message msg, long uptimeMillis)、以及sendMessageAtFrontOfQueue(Message msg) 则会对Handler 中post以及send有更好的理解。

其实sendMessageAtTime(Message msg, long uptimeMillis)、以及sendMessageAtFrontOfQueue(Message msg) 这两个方法内部实现很简单，首先是对mQueue 进行一个非null判断，如果为null则直接返回false，否则 直接执行了enqueueMessage(queue, msg, 0)方法。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

该方法可以看到，首先将当前Handler对象赋值给msg中的一个target变量，之后紧接着判断mAsynchronous值，如果为true，执行msg.setAsynchronous(true)，如果为false，直接执行queue.enqueueMessage(msg, uptimeMillis)方法，该方法的具体实现是在MessageQueue中实现的，本文主要是介绍Handler源码，对于MessageQueue将会在另一篇文章中介绍。

到这里可以看到整个消息通过Handler 发送出去了。

当然Handler中还有一些其它方法，需要关注一下

public final void removeCallbacks(Runnable r)
{
mQueue.removeMessages(this, r, null);
}

public final void removeCallbacks(Runnable r, Object token)
{
mQueue.removeMessages(this, r, token);
}

这两个方法主要作用 移除消息队列中的Runnable对象。

同时对于Remove方法Handler中还存在两个方法，分别是：

public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null);
}

public final void removeMessages(int what, Object object) {
mQueue.removeMessages(this, what, object);
}

通过上面两个方法可以理解为 移除消息队列中的 what标示的message。

另外 Handler在使用过程中常通过Message对象将发送消息进行封装，对于Message对象的获取，Handler中提供了一系列的方法。

public final Message obtainMessage()
{
return Message.obtain(this);
}

public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}

public final Message obtainMessage(int what, Object obj)
{
return Message.obtain(this, what, obj);
}

public final Message obtainMessage(int what, int arg1, int arg2)
{
return Message.obtain(this, what, arg1, arg2);
}

public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
{
return Message.obtain(this, what, arg1, arg2, obj);
}

可以看出 无论 obtainMessage()方法中传入的参数多么复杂，最重都将执行到Message.obtain(..)方法中，通过该方法获取对应的Message对象，而不是通过Message构造函数new一个Message对象。

至此 Handler中常用的方法通过源码已经分析完成。对于其中涉及到到一些其它类，读者可自行到本人到博文中去看。