【Android】由Looper引起的ThreadLocal相关分析

什么是Looper

Looper，通过名字也可以知道，是一个循环器。
Looper的核心是一个循环方法，不断地从MessageQueue中取出Message交给Handler去进行处理。
我们也都知道，一个线程只能有一个Looper，一个Looper可以对应多个Handler。那这就引出一个问题，Android是依靠什么机制来控制线程和Looper的这种1:1的关系的呢。

如何存储Looper

在没看源码之前，可以合理猜测比如每个Thread有一个私有的Map来进行存储，Key是对应的类，Value是对应的对象，似乎这样也能解决这个问题。
但是翻看源码之后发现，Thread中有对应的Map，不过不是常用的HashMap，而是：

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

这么一个Map。那么这个Map究竟是个什么玩意儿呢，得先从其外部类ThreadLocal开始分析，这就开始了这篇文章的主体，TreadLocal相关分析。

ThreadLocal

/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 *
 * 
For example, the class below generates unique identifiers local to each
 * thread.
 * A thread's id is assigned the first time it invokes {@code ThreadId.get()}
 * and remains unchanged on subsequent calls.
 * 
 * import java.util.concurrent.atomic.AtomicInteger;
 *
 * public class ThreadId {
 *     // Atomic integer containing the next thread ID to be assigned
 *     private static final AtomicInteger nextId = new AtomicInteger(0);
 *
 *     // Thread local variable containing each thread's ID
 *     private static final ThreadLocal<Integer> threadId =
 *         new ThreadLocal<Integer>() {
 *             @Override protected Integer initialValue() {
 *                 return nextId.getAndIncrement();
 *         }
 *     };
 *
 *     // Returns the current thread's unique ID, assigning it if necessary
 *     public static int get() {
 *         return threadId.get();
 *     }
 * }
 * 
 * 
Each thread holds an implicit reference to its copy of a thread-local
 * variable as long as the thread is alive and the {@code ThreadLocal}
 * instance is accessible; after a thread goes away, all of its copies of
 * thread-local instances are subject to garbage collection (unless other
 * references to these copies exist).
 *
 * @author  Josh Bloch and Doug Lea
 * @since   1.2
 */

遇事不决看一下注释是什么，我就翻译一下第一段。
这个类提供线程本地的变量。这些变量与正常变量不同，因为每个线程都是通过get和set方法访问各个线程自己的、独立的变量副本。这些实例通常希望是与线程相关联的私有静态字段（例如用户ID或者交易ID）。
知道了ThreadLocal的设计目的，接下来看一下对应的get和set方法的具体实现。

set(T value)

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

通过Thread的静态方法拿到了当前线程，然后通过当前线程拿到对应的map，也就是上文提到的ThreadLocal.ThreadLocalMap threadLocals。之后就是包了一下ThreadLocalMap的set方法，注意一下对应的Key和Value，value没什么好说的，Key的值是this。也就是说一定能在利用ThreadLocal进行线程私有变量存储的地方找到对应的ThreadLocal的初始化。
如果对应ThreadLocalMap为空的话就还要进行一个初始化，这里就是懒汉模式了。

get()

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

get方法就是利用了this去获得ThreadLocalMap.Entry然后再去拿到对应的Value值。看过HashMap源码的同学肯定对Entry这个内部类的作用很熟悉，但是这里的Entry有一些特别。

    /**
     * The entries in this hash map extend WeakReference, using
     * its main ref field as the key (which is always a
     * ThreadLocal object).  Note that null keys (i.e. entry.get()
     * == null) mean that the key is no longer referenced, so the
     * entry can be expunged from table.  Such entries are referred to
     * as "stale entries" in the code that follows.
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;
         Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }

使用的是弱引用，防止前文提到的ThreadLocal对象导致的内存泄露。

MainLooper初始化分析

有了之前讲到的源码，我们分析一下Android中MainLooper的初始化过程。
首先需要知道每一个Java程序都有一个main方法作为程序入口，Android的APP也不例外，这个方法入口在ActivityThread这个类中：

    public static void main(String[] args) {
        ......
		//在这里进行了MainLooper的初始化工作
        Looper.prepareMainLooper();

		......
    }

具体在main方法中做了什么不是这篇博客关注的，代码中有一行Looper.prepareMainLooper();也就是在这里进行了MainLooper的初始化工作.

跟着这一行点进去：

    /**
     * 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方法，进行过Android并发开发的小伙伴肯定对这个方法有印象的，使用Handler必须要先调用Looper.prepare()再调用Looper.loop()。那么我们可以看看prepare方法到底做了什么：

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

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

看到上文讲到的set方法了吧，在这里创建了线程私有的Looper对象，并且存到了ThreadLocalMap中。
这里出现的ThreadLocal实例为sThreadLocal对象，这个对象是在哪里初始化的呢？

    @UnsupportedAppUsage
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

使用的是饿汉模式，在Looper类加载的时候就进行了初始化。

回到ActivityThread的代码中，之后就是再通过get方法拿到这个Looper，然后赋值给sMainLooper。

    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

至此，prepareMainLooper方法完成。

总结

整套利用ThreadLocal存储Looper的逻辑总体还是比较清晰的，但还是有一个我自认为比较迷惑人的地方。
就是Thread只持有ThreadLocalMap实例，每个Thread对应一个ThreadLocalMap，而不是ThreadLocal。
也就是可以理解成ThreadLocal的目的是保存类信息，ThreadLocalMap才是真正存储线程的静态私有变量的容器。
也就是这么一个对应关系Thread：ThreadLocalMap == 1:1。ThreadLocal可以看做一个全局单例的类信息。