Android的Handler，Looper源码剖析

之前了解android的消息处理机制，但是源码看的少，现在把Looper，Handler，Message这几个类的源码分析一哈

android的消息处理有三个核心类：Looper,Handler和Message。其实还有一个Message Queue（消息队列），但是MQ被封装到Looper里面了，我们不会直接与MQ打交道，因此我没将其作为核心类

Looper源码：

Looper的字面意思是“循环者”，它被设计用来使一个普通线程变成Looper线程。所谓Looper线程就是循环工作的线程。

使用Looper类创建Looper线程Demo：

public class LooperThread extends Thread {    @Override    public void run() {        // 将当前线程初始化为Looper线程        Looper.prepare();                // ...其他处理，如实例化handler                // 开始循环处理消息队列        Looper.loop();    }}

1)Looper.prepare()源码

public final class Looper {    private static final String TAG = "Looper";    // sThreadLocal.get() will return null unless you've called prepare()./*如果没有调用prepare将Looper对象设置为线程的本地变量，则sThreadLocal.get()为空*//*// 每个线程中的Looper对象其实是一个ThreadLocal，即线程本地存储(TLS)对象*/    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();//当前线程的本地变量    private static Looper sMainLooper;  // guarded by Looper.class    final MessageQueue mQueue;//Looper维护的消息队列MQ    final Thread mThread;//Looper关联的当前线程    private Printer mLogging;     /** Initialize the current thread as a looper.      * This gives you a chance to create handlers that then reference      * this looper, before actually starting the loop. Be sure to call      * {@link #loop()} after calling this method, and end it by calling      * {@link #quit()}.      */    public static void prepare() {        prepare(true);    }     /* 我们调用该方法会在调用线程的TLS中创建Looper对象*/    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对象设置为当前线程的一个本地变量    }

                                                      Prepare()之后的的图:

                                                       

现在你的线程中有一个Looper对象，它的内部维护了一个消息队列MQ。注意，一个Thread只能有一个Looper对象
2）Looper.loop()源码

    /**     * Run the message queue in this thread. Be sure to call     * {@link #quit()} to end the loop. *在当前线程中执行消息队列，确定调用quit()结束循环     */    public static void loop() {        final Looper me = myLooper();//获得Looper对象        if (me == null) {            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        final MessageQueue queue = me.mQueue;//获得Loop对象关联的消息队列         /*没看懂，不影响理解*/         // 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，从消息队列中获取消息Message            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);            }            /*这一句非常重要，将真正的处理工作交给message的target，即后面要讲的handler*/            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();   // 回收message资源        }    }    /**     * Return the Looper object associated with the current thread.  Returns     * null if the calling thread is not associated with a Looper. *返回与当前线程相关联的Looper对象     */    public static Looper myLooper() {        return sThreadLocal.get();//其实就是从线程的本地变量里面取值    }    /**     * Return the {@link MessageQueue} object associated with the current     * thread.  This must be called from a thread running a Looper, or a     * NullPointerException will be thrown. * 返回与当前线程相关联的MessageQueue对象     */    public static MessageQueue myQueue() {        return myLooper().mQueue;    }    /*初始化Looper的两个属性，关联的线程和消息队列*/    private Looper(boolean quitAllowed) {        mQueue = new MessageQueue(quitAllowed);        mThread = Thread.currentThread();    }

调用loop方法后，Looper线程就开始真正工作了，它不断从自己的MQ中取出队头的消息(也叫任务)执行

                   
Looper有了基本的了解，总结几点：
1.每个线程有且最多只能有一个Looper对象，它是一个ThreadLocal就是Looper对象
2.Looper内部有一个消息队列，loop()方法调用后线程开始不断从队列中取出消息执行
3.Looper使一个线程变成Looper线程。
那么，我们如何往MQ上添加消息呢？下面有请Handler

Handler分析：

handler扮演了往MQ上添加消息和处理消息的角色（只处理由自己发出的消息），即通知MQ它要执行一个任务(sendMessage)，并在loop到自己的时候执行该任务(handleMessage)，整个过程是异步的。handler创建时会关联一个looper，默认的构造方法将关联当前线程的looper，不过这也是可以set的

为之前的LooperThread类加入Handler：

public class LooperThread extends Thread {    private Handler handler1;    private Handler handler2;    @Override    public void run() {        // 将当前线程初始化为Looper线程        Looper.prepare();                // 实例化两个handler        handler1 = new Handler();                       // 开始循环处理消息队列        Looper.loop();    }}

加入handler后的效果：

1，Handler发送消息

可以使用

post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int), sendMessage(Message), sendMessageAtTime(Message, long)和 sendMessageDelayed(Message, long)这些方法向MQ上发送消息了。光看这些API你可能会觉得handler能发两种消息，一种是Runnable对象，一种是message对象，这是直观的理解，但其实post发出的Runnable对象最后都被封装成message对象

/**     * Causes the Runnable r to be added to the message queue.     * The runnable will be run on the thread to which this handler is      * attached.      *       * @param r The Runnable that will be executed.     *      * @return Returns true if the Runnable was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */ /*把一个Runnable对象加入消息队列，任务将在当前Handler绑定的线程中执行，说白了就是当前线程执行任务*/    public final boolean post(Runnable r)    {       return  sendMessageDelayed(getPostMessage(r), 0);    }        /**     * Causes the Runnable r to be added to the message queue, to be run     * at a specific time given by <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.     * The runnable will be run on the thread to which this handler is attached.     *     * @param r The Runnable that will be executed.     * @param uptimeMillis The absolute time at which the callback should run,     *         using the {@link android.os.SystemClock#uptimeMillis} time-base.     *       * @return Returns true if the Runnable 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 Runnable will be processed -- if     *         the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     */    public final boolean postAtTime(Runnable r, long uptimeMillis)    {        return sendMessageAtTime(getPostMessage(r), uptimeMillis);    }        /**     * Causes the Runnable r to be added to the message queue, to be run     * at a specific time given by <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.     * The runnable will be run on the thread to which this handler is attached.     *     * @param r The Runnable that will be executed.     * @param uptimeMillis The absolute time at which the callback should run,     *         using the {@link android.os.SystemClock#uptimeMillis} time-base.     *      * @return Returns true if the Runnable 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 Runnable will be processed -- if     *         the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     *              * @see android.os.SystemClock#uptimeMillis     */    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)    {        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);    }        /**     * Causes the Runnable r to be added to the message queue, to be run     * after the specified amount of time elapses.     * The runnable will be run on the thread to which this handler     * is attached.     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>     * Time spent in deep sleep will add an additional delay to execution.     *       * @param r The Runnable that will be executed.     * @param delayMillis The delay (in milliseconds) until the Runnable     *        will be executed.     *             * @return Returns true if the Runnable 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 Runnable will be processed --     *         if the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     */    public final boolean postDelayed(Runnable r, long delayMillis)    {        return sendMessageDelayed(getPostMessage(r), delayMillis);    }        /**     * Posts a message to an object that implements Runnable.     * Causes the Runnable r to executed on the next iteration through the     * message queue. The runnable will be run on the thread to which this     * handler is attached.     * <b>This method is only for use in very special circumstances -- it     * can easily starve the message queue, cause ordering problems, or have     * other unexpected side-effects.</b>     *       * @param r The Runnable that will be executed.     *      * @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.     */    public final boolean postAtFrontOfQueue(Runnable r)    {        return sendMessageAtFrontOfQueue(getPostMessage(r));    }    /**     * Pushes a message onto the end of the message queue after all pending messages     * before the current time. It will be received in {@link #handleMessage},     * in the thread attached to this handler.     *       * @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.     */ /*把一个消息放入消息队列中，返回true*/    public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }    /**     * Sends a Message containing only the what value.     *       * @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.     */ /*把一个只有what的消息放入到消息队列中*/    public final boolean sendEmptyMessage(int what)    {        return sendEmptyMessageDelayed(what, 0);    }    /**     * Sends a Message containing only the what value, to be delivered     * after the specified amount of time elapses.     * @see #sendMessageDelayed(android.os.Message, long)      *      * @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.     */    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {        Message msg = Message.obtain();        msg.what = what;        return sendMessageDelayed(msg, delayMillis);    }    /**     * Sends a Message containing only the what value, to be delivered      * at a specific time.     * @see #sendMessageAtTime(android.os.Message, long)     *       * @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.     */    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {        Message msg = Message.obtain();        msg.what = what;        return sendMessageAtTime(msg, uptimeMillis);    }    /**     * Enqueue a message into the message queue after all pending messages     * before (current time + delayMillis). You will receive it in     * {@link #handleMessage}, in the thread attached to this handler.     *       * @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 final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }

Handler处理消息：

/**     * Subclasses must implement this to receive messages. *子类必须实现这个方法接收消息     */    public void handleMessage(Message msg) {    }        /**     * Handle system messages here. *处理系统的消息， 处理消息，该方法由looper调用   msg.target.dispatchMessage(msg);就是把消息交给Handler来处理     */    public void dispatchMessage(Message msg) {        if (msg.callback != null) {// 如果message设置了callback，即runnable消息，处理callback！            handleCallback(msg);        } else {  // 如果handler本身设置了callback，则执行callback            if (mCallback != null) {/* 这种方法允许让activity等来实现Handler.Callback接口，避免了自己编写handler重写handleMessage方法*/                if (mCallback.handleMessage(msg)) {                    return;                }            }// 如果message没有callback，则调用handler的钩子方法handleMessage            handleMessage(msg);        }    }

相关理论看之前的文章http://blog.csdn.net/tuke_tuke/article/details/50783153