Android Looper源码解析

  我们都知道，Android中使用Looper来管理线程的消息队列，我们可以看看Google的介绍

   Class used to run a message loop for a thread.  Threads by default do not have a message loop associated with them; to create one, call {@link #prepare} in the thread that is to run the loop, and then {@link #loop} to have it process messages until the loop is stopped.

   大意是，线程默认是没有消息队列的，此类会在一个线程中运作一个消息循环队列。如果想使用它，先调用Looper.prepare()方法，然后调用Looper.loop()方法。

   那它的原理是什么呢？为什么调用Looper的静态prepare()方法就能给当前线程加入Looper呢 ？Looper是如何让一个线程来一直执行其消息队列呢？带着上面的问题，我们今天来解析一下它的源码。

一、prepare()方法:

 源码：

public static void prepare() {        prepare(true);}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));}

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

可以看出，我们调用prepare()方法，其本质上是调用了私有的prepare(true)，并调用了Looper的构造方法创建了一个新的实例，里面初始化了MessageQueue(消息队列，我们以后也会解析其源码)。true表示我们创建的子线程的Looper是一定能被停止的，那么什么线程不能被停止呢？当然是我们的UI线程主线程。

我们在来看看  sThreadLocal.set(...);  这行代码：

public void set(T value) {        Thread currentThread = Thread.currentThread();        Values values = values(currentThread);        if (values == null) {            values = initializeValues(currentThread);        }        values.put(this, value);}

我们可以简单把上面的代码理解为给当前线程加入了指向Looper的变量。我们以后就可以通过当前线程来获取对应的Looper对象。

二、myLooper()方法：

public static @Nullable Looper myLooper() {        return sThreadLocal.get();}

其调用的为：

public T get() {        // Optimized for the fast path.        Thread currentThread = Thread.currentThread();        Values values = values(currentThread);        if (values != null) {            Object[] table = values.table;            int index = hash & values.mask;            if (this.reference == table[index]) {                return (T) table[index + 1];            }        } else {            values = initializeValues(currentThread);        }        return (T) values.getAfterMiss(this);    }

即本质上是得到当前线程，然后获取其中的Looper对象。

所以，调用了prepare()方法之后，当前线程即保留了Looper对象的引用，我们可以通过myLooper()方法获取当前线程的Looper对象。

顺便贴出主线程初始化Looper的代码：

    /**     * Initialize the current thread as a looper, marking it as an     * application's main looper. The main looper for your application     * is created by the Android environment, so you should never need     * to call this function yourself.  See also: {@link #prepare()}     */    public static void prepareMainLooper() {        prepare(false);        synchronized (Looper.class) {            if (sMainLooper != null) {                throw new IllegalStateException("The main Looper has already been prepared.");            }            sMainLooper = myLooper();        }    }

可以看出，其调用了prepare(false)方法来为主线程创建一个不会停止的Looper，并且Looper类中一个静态的Looper对象，指向了主线程的Looper对象。

三、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()的方法就很简单了，其本质上是先从当前线程中得到Looper对象，然后在得到Looper对象中的MessageQueue对象，从中获取下一个Message对象，然后进行事件的分发。

从上面的解析也可以看出，Looper只是不停的从MessageQueue中不停的取出Message，然后在进行事件处理。而我们的Message的队列管理是由MessageQueue来执行的。