Handler解析(一)：是如何实现线程之间的切换

    在Android中，一般情况下(特殊情况先不说)只有UI线程才能对View进行操作，然而为了避免ANR等，耗时操作都放到子线程进行，操作完成之后再切换到UI线程，而Handler正好能够完成从子线程切换到UI线程的工作，那么Handler是如何从子线程切换到UI线程的呢？

消息传递机制切换

---

要了解Handler，就首先需要了解Android的消息传递机制，整个消息传递机制有四部分组成：

1.Message
消息，即线程间传递的对象，传递的信息包含在其中。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
2. Message Queue
消息队列，用来存放通过Handler发布的消息，按照先进先出执行。
3. Handler
Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
4. Looper
循环器，扮演Message Queue和Handler之间桥梁的角色，循环取出Message Queue里面的Message，并交付给相应的Handler进行处理。

它们之间的协作如下图，

Handler

---

首先来看看Handler的实现源码

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

Handler的构造函数，在构造函数中初始化了一个Looper 和 MessageQueue。

Looper

---

接下来看看Looper.myLooper()的实现

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

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

可以发现Looper.myLooper()是通过ThreadLocal中读取出来的，而在Handler的构造函数中，若Looper.myLooper()返回为null，则会抛出RuntimeException；而myLooper()函数被@Nullable修饰，说明它是可以返回为null的，我们必须要保证在初始化Handler的时候，myLooper()不会返回为null。那继续看看sThreadLocal是在哪里初始化的

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

在Looper中，有一个prepare的函数，在其中对Looper进行了初始化，Looper对象保存在sThreadLocal中。那接下来看看ThreadLocal是何物

ThreadLocal

---

看ThreadLocal中get()与set()的源码如下

   public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

  public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

 ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

其中通过 Thread.currentThread()获取了当前所在线程，然后通过getMap读取当前线程的属性threadLocals，返回一个ThreadLocalMap对象，然后从map中读取或者写入当前的值。

static class ThreadLocalMap {

  static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /...省略代码若干.../

   ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
}

通过代码可以发现ThreadLocalMap其实内部维护了一个Entry的数组。其中值得注意的是Entry的key为弱引用，value为强引用。所以通过ThreadLocal来保存的话，线程未推出之前，value会一直被引用，从而可能导致内存泄漏。

通过上面的代码分析，可以了解到，通过Looper.prepare()创建的looper是保存在当前线程的threadLocals中，不同线程调用Looper.prepare()创建looper会将looper对象保存在对应的线程当中，保证了不同线程之前的looper实例单独保存，互不影响。

MessageQueue

---

接下里看看MessageQueue，从Handler的源码中可以发现，Handler所对应的MessageQueue是从Looper中获取的，

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

Looper的构造函数初始化了一个MessageQueue，从上面的结论可以得知，不同线程调用Looper.prepare()创建looper会将looper对象保存在对应的线程当中，保证了不同线程之前的looper实例单独保存，互不影响。同理，不同线程之间的MessageQueue也是单独保存，互不影响。

因此我们可以得知，Handler在当前线程初始化，则它对应的Looper和MessageQueue都保存在当前的线程当中，与其它的线程是隔离开来的。再来看看Looper中的loop函数，它负责从MessageQueue中取出message。

   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;
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
               return;
            }
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what);
            }

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }
            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函数中我们可以发现最终调用了 msg.target.dispatchMessage(msg);其中的target即发送消息的handler。

如何实现线程之间切换

---

最终回到Handler是如何实现线程之间的切换的呢？例如现在有A、B两个线程，在A线程中有创建了handler，然后在B线程中调用handler发送一个message。

通过上面的分析我们可以知道，当在A线程中创建handler的时候，同时创建了MessageQueue与Looper，Looper在A线程中调用loop进入一个无限的for循环从MessageQueue中取消息，当B线程调用handler发送一个message的时候，会通过msg.target.dispatchMessage(msg);将message插入到handler对应的MessageQueue中，Looper发现有message插入到MessageQueue中，便取出message执行相应的逻辑，因为Looper.loop()是在A线程中启动的，所以则回到了A线程，达到了从B线程切换到A线程的目的。

总结

---

1.Handler初始化之前，Looper必须初始化完成。UI线程之所以不用初始化，因为在ActivityThread已经初始化，其他子线程初始化Handler时，必须先调用Looper.prepare()。

2.通过Handler发送消息时，消息会回到Handler初始化的线程，而不一定是主线程。

3.使用ThreadLocal时，需要注意内存泄漏的问题。