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 sThreadLocal = new ThreadLocal(); 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时，需要注意内存泄漏的问题。
更多相关文章
- Android 接收RabbitMq服务器发送消息
- android 启动线程注意的问题
- Android开发学习笔记-关于Android的消息推送以及前后台切换
- android 程序初始化界面.. .
- Android 云端推送C2DM php实现向终端推送消息
- android实现多线程断点续传功能
- android中执行线程的部分代码
- Android实现多线程断点下载的方法