最近翻译了一片关于Context泄露的文章,其中提到了Handler的一些知识点。想想当初自己研究这块的时候也是看着源码一点点抠出来的。只不过那时候没有做个总结，现在正好借着这个机会把这块知识点总结下，也算是做个备注了。

我们知道Android应用启动的时候会执行ActivityThread类的main方法，详情请参见罗升阳的这篇文章。main方法中会为主线程创建一个Looper对象，这个Looper中维护了一个消息队列MessageQueen。Looper会不断的从消息队列中取消息，然后交给消息的target对象(即Handler)去处理这个消息。如果队列中没有消息，那么Looper就会进入等待状态直到队列中有新消息。大概的过程就是这样，下面我们通过源码来了解下整个过程。

首先来看看ActivityThread的main方法，这里只保留了跟本文相关的主要代码。

public static void main(String[] args) {

    Looper.prepareMainLooper();

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

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

    Looper.loop();
}

main方法中首先调用了Looper.prepareMainLooper()来为主线程创建一个Looper对象，然后在调用Looper.loop()方法进入一个无限循环状态不断的从消息队列中取消息进行处理。那么，我们再跟踪到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();
    }
}

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

prepareMainLooper()首先调用Looper的prepare()方法创建Looper对象，然后再把这个looper对象赋值给sMainLooper。同时在创建过程中确保了主线程只有一个Looper对象。Looper对象在创建的时候会同时创建一个MessageQueen对象，所有的消息都会存储在这个队列中。Looper也是从这个队列中取消息来进行处理的。并且，这个Looper对象的作用域为整个线程。 这样，只要是在该线程内发送的消息，都会发送到这个Looper对象的消息队列中进行处理。

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

main方法最后调用了Looper的loop()方法让Looper工作起来，也就是处理消息队列中的消息。

public static void loop() {
    final Looper me = myLooper();
    final MessageQueue queue = me.mQueue;
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }

        msg.target.dispatchMessage(msg);
    }
}

loop()方法先拿到当前线程的Looper对象，然后再拿到Looper的MessageQueen对象。最后进入无限循环，不断的从消息队列中取出消息。然后再把消息交给这个消息的target对象进行处理。那么现在的问题就是消息是从哪里来的以及这个target对象又是谁。

一般情况下，我们会通过handler的sendMessage(msg)方法来发送一条消息。那么我们就跟踪下这个方法，看看这个消息最终被发送到哪里去了。

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;
    return enqueueMessage(queue, msg, uptimeMillis);
}

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;//注意:这里把this(即发送消息的那个Handler对象)赋值给了消息的target对象。
                    //所以，在Looper.loop()方法中的target就是一个Handler对象
    return queue.enqueueMessage(msg, uptimeMillis);
}

可以看到通过层层调用，最终调用了sendMessageAtTime()方法，该方法又调用了enqueueMessage()方法将方法放入一个消息队列中。那么这个消息队列又跟Looper中的消息队列有啥关系呢？我们来看看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;
}

已经很清晰明了了。当创建Handler对象的时候，首先会通过Looper.myLooper()拿到当前线程的Looper对象，然后再拿到Looper的MessageQueen对象。也就是说我们的消息是被发送到当前线程的Looper的消息队列中了。这样Looper.loop()拿到的消息就是我们发送的消息，然后再把消息交给发送这个消息的Hanlder来进行处理。即Looper.loop()中的msg.target.dispatchMessage(msg)。那么我们再来看看handler.dispatchMessage(msg)是怎么处理这个消息的。

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

我们这里暂时不关心msg的callback以及handler的mCallback。这里最终会调用handleMessage(msg)方法，那我们当然要追踪进去看看了。

public void handleMessage(Message msg) {
}

没错，是个空方法。其实这里就是我们使用Handler的时候实现我们处理消息逻辑的地方。一般我们是这么使用Handler的：

private static Handler mHandler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        //处理逻辑
    }
};

至此，整个Handler机制就串通了：从消息的发送到消息的处理。

如果我们在主线程中使用Handler，那我们不用去管Looper。因为，framew已经为我们的主线程创建好了Looper。但是，如果我们要在其他线程中使用Handler这套机制，那我们就需要自己去创建Looper并调用Looper.prepare()，否则就会发生异常。