Android Handler体系部分源码学习

先来看一下Handler的基本流程：



（1）先分析第一部分的代码 Looper.prepare()：

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对象，然后存入ThreadLocal对象中，同时也就实现了每个线程都有相互独立Looper

（2）Looper.loop()

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the 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;

    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();

    final long ident = Binder.clearCallingIdentity();

    for (;;) {

        Message msg = queue.next(); // might block
       
if (msg == null) {

            // No message indicates that the message queue is quitting.
           
return;

        }

        // This must be in a local variable, in case a UI event sets the logger
        Printer logging = me.mLogging;

        if (logging != null) {

            logging.println(">>>>> Dispatching to " + msg.target + " " +

                    msg.callback + ": " + msg.what);

        }

        msg.target.dispatchMessage(msg);

        if (logging != null) {

            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);

        }

        // Make sure that during the course of dispatching the
        // identity of the thread wasn't corrupted.
       
final long newIdent = Binder.clearCallingIdentity();

        if (ident != newIdent) {

            Log.wtf(TAG, "Thread identity changed from 0x"
                    + Long.toHexString(ident) + " to 0x"
                    + Long.toHexString(newIdent) + " while dispatching to "
                    + msg.target.getClass().getName() + " "
                    + msg.callback + " what=" + msg.what);

        }

        msg.recycleUnchecked();
    }
}

loop();开始调用以后就进入了死循环
并且不断获取下一个Message，
再将Message交给它的target的dispatchMessage方法进行处理。

（3）new Handler（）

public Handler() {

    this(null, false);

}

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;

}

我们来看看 new Handler（）到底做了什么,
其实就是获得当前线程的Looper，使得Handler与Looper进行绑定，这是默认的实现。
同时也有带有Looper的构造函数，这就代表了Handler其实可以绑定其他线程的Looper。

（4）post消息

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;

    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中最终调用的就是将消息放入消息队列的方法
queue.enqueueMessage(msg, uptimeMillis);

总结：
最后，通过简单的学习几个相关类的源码，我们就可以试着理解为什么平时我们可以用Handler来解决子线程里更新UI的问题了：
（1）首先我们在主线程中 newHandler 绑定到了主线程中的Looper
（2）post出去的消息也就发到了UI线程中Looper的消息队列中
（3）Looper循环处理Message中的消息其实是回调了 Handler中的处理方法
（4）同时Looper是在它绑定的的线程里执行处理方法的，其实就相当于在UI线程中执行了处理代码，也就可以更新UI了。

这样Handler的原理是基本打通了，但是有很多细节还没能深入学习，一部分是因为再往下层涉及到的东西我还没看懂，估计还需要一段时间，所以先把阶段性的成果先放出来