Android中Handler的理解与总结

android的异步处理消息机制Handler这个问题是老生常谈哪，这个要追溯到一个面试的场景了，面试官说，handler发送完消息后，什么时候触发循环，这个我说了，handler源码中有个looper，这个是用来循环取出handler发送到消息队列（messageQueue）中的消息，一旦Looper开启Looper.loop()就开启无限循环，直接取出MessageQueue中所有的消息，然后面试官不知道是他怎么理解的，我说的是looper.loop（）就开启循环，他没说话，可能不在一个频道上抑或是我回答的不对？我感觉他也不是特别的理解吧，哎，有点坑哪，这面试真是醉了，什么样的面试官都会遇到，面试还真是运气加上实力，我觉得吧，可能还是缘分未到吧，但是我喜欢总结，我觉得自己要深刻的理解，现在我就去再去深入的看下这个Handler，下次再问到此类问题信手拈来，插一句，可能那个面试官他真的不是特别理解吧！

 首先，咱们理解几个概念，见名知意吧，下面的博客中会以口语化形式表述出来。

 Message(消息),MessageQueue(消息队列),Looper(循环，很重要),Handler(用来发送和处理消息)

1.Handler分析发送消息的过程

Handler mHandler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
    }
};

上面那种写法咱们是咱们最常用的，new完后，重写handleMessage方法，里面的传递介质Message就是我们发送的消息，我们看看他的内部是如何处理的，直接点击Handler

/**
 * Default constructor associates this handler with the {@link Looper} for the
 * current thread.
 *
 * If this thread does not have a looper, this handler won't be able to receive messages
 * so an exception is thrown.
 */
public Handler() {
    this(null, false);
}

看到他的构造函数使用的这类里面的构造，传入参数是null 和 false，我们继续点击this这个函数

/**
 * Use the {@link Looper} for the current thread with the specified callback interface
 * and set whether the handler should be asynchronous.
 *
 * Handlers are synchronous by default unless this constructor is used to make
 * one that is strictly asynchronous.
 *
 * Asynchronous messages represent interrupts or events that do not require global ordering
 * with respect to synchronous messages.  Asynchronous messages are not subject to
 * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.
 *
 * @param callback The callback interface in which to handle messages, or null.
 * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
 * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
 *
 * @hide
 */
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;
}

第一个参数是一个回调的接口，这个接口也是在Handler内部定义的如下所示:

/**
 * Callback interface you can use when instantiating a Handler to avoid
 * having to implement your own subclass of Handler.
 *
 * @param msg A {@link android.os.Message Message} object
 * @return True if no further handling is desired
 */
public interface Callback {
    public boolean handleMessage(Message msg);
}

其实也是最后调用handlerMessage(Message msg)这个方法，就像我们刚才使用的那种方式，我们可以这样理解，这个Handler有好几种的使用方式，可以传接口，也可以直接new出来，然后重写handlerMessage方法，几个入口吧。

第二个参数是一个boolean类型，这个消息是否是异步的，这里我们new出来的默认是false，也就是不是异步的消息，是同步的消息，异步的消息这里提前说下，异步消息就不能保证顺序了，因为这里面还有MessageQueue消息队列的概念，下面会继续说的。

ok，new完handler后，可以看到给mLooper 设置了与当前线程相关联的Looper对象，mQueue为当前looper对象里面的消息队列，而looper和messageQueue是在Looper对象实例化后相关联的，可以看下两者的关联代码

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

ok，上面讲的是new完Handler后的代码追踪，也就是在newHanlder后，获取到当前的looper对象并设置到Handler里面的成员变量mLooper，还有将Handler成员变量消息队列mQueue 设置为当前Looper对象所关联的消息队列mLooper.mQueue;

下面这个步骤就是handler发送消息了，追踪下代码

/**
 * Enqueue a message into the message queue after all pending messages
 * before the absolute time (in milliseconds) <var>uptimeMillis</var>.
 * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
 * Time spent in deep sleep will add an additional delay to execution.
 * You will receive it in {@link #handleMessage}, in the thread attached
 * to this handler.
 * 
 * @param uptimeMillis The absolute time at which the message should be
 *         delivered, using the
 *         {@link android.os.SystemClock#uptimeMillis} time-base.
 *         
 * @return Returns true if the message was successfully placed in to the 
 *         message queue.  Returns false on failure, usually because the
 *         looper processing the message queue is exiting.  Note that a
 *         result of true does not mean the message will be processed -- if
 *         the looper is quit before the delivery time of the message
 *         occurs then the message will be dropped.
 */
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);
}

不管你是sendMessage还是sendMessageDelayed最终代码都会执行到这个sendMessageAtTime方法中，可以看到第一个参数是Message我们的传递介质，消息载体，第二个就是时间，消息的绝对时间，然后接着追踪代码

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

在这里可以看到msg.target = this,可以很好的理解，即当前消息的目标，也就是发送消息的句柄是当前的对象也就是Handler，将其赋值，然后判断是否是异步的消息，如果是，设置为true，然后将这个消息入队返回true 或者false，表示消息进入队列是否成功

继续往下看

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(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

        msg.markInUse();
        msg.when = when;
        Message p = mMessages;

这是消息入队的代码，会先判断当前目标target是否为null，这个消息是否正在使用等最后返回true，表示消息入队成功。

 2.疑问:到这里我们可能要问了，这逻辑已经顺着下来了，handler什么时候去处理消息哪，现在只有入没有处理消息啊？

   ok，上述1的过程只是消息的发送过程，现在我们来看看消息的处理，我们不要忘记了Looper这个对象，先查看其源码，其中有这个方法

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
public static void loop() {

当looper调用这个方法后会开启无限循环，循环从messageQueue中取出message，然后调用msg.target.dispatchMessage去处理消息，可以看下代码

try {
    msg.target.dispatchMessage(msg);
} finally {
    if (traceTag != 0) {
        Trace.traceEnd(traceTag);
    }
}

而target就是当前new的handler，我们看handler里面dispatchMessage的方法是如何处理的

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

看到上面的注释说明”在这里处理系统的消息“，然后我们惊喜的发现了callback，对，没错，就是在最初初始化handler的时候，传的callback参数，但是我们这个是null啊，对的，所有他执行了else，执行了handleMessage，然后这就是我们为什么重写handleMessage的原因，好了，但是callback的使用场景是什么

new Handler().post(new Runnable() {
    @Override
    public void run() {
       new TextView(TestActivity.this).setText("xxxxx");
    }
});

我们直接使用handler.post 发送了一个runnable，点击post后，可以看到执行的顺序和sendMessage是一样的

public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}

不过是通过getPostMessage(r)获取了一个消息，而此时callback = r；

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

此时的callback不为空，那最后执行到这个dispatchMessage时，由于callback不是null，所以直接执行了runnable的run方法，不信，请看代码

private static void handleCallback(Message message) {
    message.callback.run();
}

整个流程走完了，但是回到最初的问题，面试官说，什么时候触发循环，因为我们已经知道必须调用looper.loop()方法才能触发无限循环，说这样也没错啊，但是我们new的时候并没有使用looper的loop方法啊，ok，问题就在这里，我们Activity在初始化的时候，系统已经帮我们做好了

Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();
thread.attach(false);

if (sMainThreadHandler == null) {
    sMainThreadHandler = thread.getHandler();
}

if (false) {
    Looper.myLooper().setMessageLogging(new
            LogPrinter(Log.DEBUG, "ActivityThread"));
}

// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();

在ActivityThread这个类中，系统初始了mainLooper，所以new Handler后默认为mainLooper，最下面的那个Looper.loop(),系统已经帮助我们开启消息循环了，比如我们之前经常这样写

  new Thread(){
        public void run(){
            Looper.prepare();
            handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                }
            };
            Looper.loop();
        }
    }.start();
}

上述代码是在子线程中使用handler，这个时候要注意，因为已经切换了线程，不再是默认的UI主线程，所以looper也不再是main Looper，所以Looper.prepare是将当前子线程绑定到当前looper对象，最后一定要开启消息循环，这是最经典的写法和使用。

综上所述，可能我没有get到面试官的点吧，抑或是面试官在这个问题上也存在着疑问吧，不管怎么说吧，自己都要要求自己去理解，不能再知道表层了，与君共勉吧！

参考文章：

http://blog.csdn.net/lmj623565791/article/details/38377229