Handler Looper MessageQueue HandlerThread的那些事

概述：

Handler是Android系统提供的异步消息通信机制，在程序开发中，经常用到Handler在不同的组件之间发送消息，不同的线程之间也可以利用Handler通信，在Handler通信中，包含3个重要部分Handler,Looper,MessageQueue。

Looper创建消息队列：

在日常开发中，我们经常在UI线程中创建一个Handler对象，然后重写其handleMessage方法，在其他线程或者组件可以利用该Handler往UI线程中发送异步消息，回调相关方法进行处理，那么其内部是怎样工作的呢？

下面我们将分析UI线程中消息通信机制的运作过程。

消息处理机制中，所有消息都是由Handler发送到Looper创建的消息队列，Looper对象不停从消息队列中获取消息，最后分发给Handler处理

那么问题来了：

1，UI线程的消息队列怎样创建,并且进入消息循环

2，Handler如何将消息发送到消息队列

3，Looper从消息队列取到消息后又是怎样处理。

先来看一下UI线程中消息队列的创建过程。大家都知道，Android启动一个新的应用程序，会创建一个新的进程，执行ActivityThread的main函数，创建Looper消息队列，并进入消息循环。同时还会创建一个Handler对象，绑定到UI线程的消息队列，在Activity生命周期中，onCreate，onPause等方法都是由该Handler对象往UI线程发消息，最后调起来的。

public final class Looper {    private static final String TAG = "Looper";    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();    private static Looper sMainLooper;  // guarded by Looper.class    final MessageQueue mQueue;    final Thread mThread;    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));    }    public static void prepareMainLooper() {        prepare(false);        synchronized (Looper.class) {            if (sMainLooper != null) {                throw new IllegalStateException("The main Looper has already been prepared.");            }            sMainLooper = myLooper();        }    }    /** Returns the application's main looper, which lives in the main thread of the application.     */    public static Looper getMainLooper() {        synchronized (Looper.class) {            return sMainLooper;        }    }    /**     * Run the message queue in this thread. Be sure to call     * {@link #quit()} to end the 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.recycle();        }    }    /**     * Return the Looper object associated with the current thread.  Returns     * null if the calling thread is not associated with a Looper.     */    public static Looper myLooper() {        return sThreadLocal.get();    }    public static MessageQueue myQueue() {        return myLooper().mQueue;    }    private Looper(boolean quitAllowed) {        mQueue = new MessageQueue(quitAllowed);        mThread = Thread.currentThread();    }    /**     * Return the Thread associated with this Looper.     */    public Thread getThread() {        return mThread;    }    /** @hide */    public MessageQueue getQueue() {        return mQueue;    }}

Looper类中sMainLooper即UI线程中的Looper对象，通过调用prepareMainLooper，最终会进入prepare函数，创建一个Looper对象，在Looper的构造函数中，创建一个消息队列。

调用loop()函数会进入消息循环，通过next函数获取消息，如果消息队列中没有消息，这里会阻塞，获取消息后通过msg.target.dispatchMessage(msg)将消息分发到Handler处理。

至此，UI线程中消息队列和循环的创建过程已经分析完毕，接下来我们再看Handler实现方式，Handler是怎样将消息发送到消息队列，以及从消息队列中取出消息后，Handler如何处理。

Handler: 

public class Handler {    private static final boolean FIND_POTENTIAL_LEAKS = false;    private static final String TAG = "Handler";    public interface Callback {        public boolean handleMessage(Message msg);    }        /**     * Subclasses must implement this to receive messages.     */    public void handleMessage(Message msg) {    }        /**     * Handle system messages here.     */    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }    /**     * Default constructor associates this handler with the {@link Looper} for the     * current thread.     *     * If this thread does not have a looper, this handler won't be able to receive messages     * so an exception is thrown.     */    public Handler() {        this(null, false);    }    public Handler(Callback callback) {        this(callback, false);    }    public Handler(Looper looper) {        this(looper, null, false);    }    public Handler(Looper looper, Callback callback, boolean async) {        mLooper = looper;        mQueue = looper.mQueue;        mCallback = callback;        mAsynchronous = async;    }    private static Message getPostMessage(Runnable r) {        Message m = Message.obtain();        m.callback = r;        return m;    }    public final boolean post(Runnable r)    {       return  sendMessageDelayed(getPostMessage(r), 0);    }    public final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }   public boolean sendMessageAtTime(Message msg, long uptimeMillis) {        MessageQueue queue = mQueue;        if (queue == null) {            RuntimeException e = new RuntimeException(                    this + " sendMessageAtTime() called with no mQueue");            Log.w("Looper", e.getMessage(), e);            return false;        }        return enqueueMessage(queue, msg, uptimeMillis);    }    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }  public final Looper getLooper() {        return mLooper;    }}

每个Handler对象必须关联一个Looper对象，Handler发送消息和接收消息都是基于这个Looper，Handler有多个构造函数，大致可以分为两类，含有Looper参数的和不含Looper参数的。含有Looper参数的构造函数，会使用参数传递的Looper对象，不含Looper参数使用当前线程中的Looper对象，如果线程没有创建一个Looper对象，则会抛出异常。

Handler关联一个Looper对象后，就可以往Looper对象创建的消息队列中发送消息，从源码来看，发送消息的方式有两种，一种是post，一种是send。

对于post方式，需要传入一个Runnable对象，这是一个回调对象，具体用途，在消息处理的时候再说，post传入runnable对象后，会调用gePostMessage方法构建一个msg，设置msg.callback为传入的runnable对象，最后调用send方式将消息发送到消息队列。所以，不管是post方法还是send方法，最后都是调用sendMessageAtTime，然后调用enqueueMessage方法，将消息放入到消息队列中。

消息发送到消息队列后，该如何处理呢。上面我们提到。Looper.loop()调用后，会不停的查询消息队列是否有消息，如果有，会调用msg.target.dispatchMessage()处理消息，msg.target即为发送该msg的Handler对象，dispatchMessage()方法中：

    /**     * Handle system messages here.     */    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }

首先会判定msg.callback是否为空，这个msg.callback就是上面提到的post方式发送消息传入的Runnable对象，如果不为空，则调用handleCallback(msg); 这个函数里面会导致Runnable对象的run方法被调用。如果msg.callback为null，则判定mCallback是否为空，这个callback对象是Handler内部定义的接口，Handler构造函数可以传入一个Callback对象，如果Handler对象创建没有传入callback对象，那么mCallback为null，否则，调用该callback的handleMessage函数， 最后，调用Handler重写的handleMessage函数。整个过程可以用下面的时序图来表示。

上面分析了消息队列的创建与循环，Handler与Looper以及消息队列的关系，以及Handler如何发送和处理消息。可以用下面这个结构图来表示整个异步消息机制的运作流程

HandlerThread:

上面分析都是针对UI线程，如果我们想在自定义的线程中定义一个Handler，该怎么操作呢。

从上文分析可知，Handler对象必须依赖一个Looper对象，自定义线程中，并没有创建Looper对象。

有三种方式可以在自定义线程中创建Hander

1，使用带Looper对象的Handler构造函数，将主线程的Looper对象传入Handler构造函数中

Handler mHandler = new Handler(getMainLooper());

这种方式定义的Handler对象，使用了UI线程的消息队列，消息处理还是在UI线程中，和主线程中定义Handler，传入自定义线程没有任何区别。

2，自定义线程类，创建Looper对象，并且调用Looper.loop()方法开始消息循环。

3，使用HandlerThread类，这种方式其实就是第二种，只是Android系统已经帮我们做好了所有的工作，调用方便。

    @Override    public void run() {        mTid = Process.myTid();        Looper.prepare();        synchronized (this) {            mLooper = Looper.myLooper();            notifyAll();        }        Process.setThreadPriority(mPriority);        onLooperPrepared();        Looper.loop();        mTid = -1;    }        public Looper getLooper() {        if (!isAlive()) {            return null;        }                // If the thread has been started, wait until the looper has been created.        synchronized (this) {            while (isAlive() && mLooper == null) {                try {                    wait();                } catch (InterruptedException e) {                }            }        }        return mLooper;    }

从HandlerThread的源码可以看到，实现方式和UI线程消息队列创建的方式类似，这里我们不再赘述。

HandlerThread类使用很简单：

HandlerThread ht = new HandlerThread("test");Handler mHandler = new Handler(ht.getLooper());mHandler.post(new Runnable() {    public void run(){        Log.e("HandlerThreadTest", "test handlerThread");}}

Handler消息通信机制是Android系统提供的非常重要的组件，开发中，应用非常广泛，我们不仅要知其然，还要知其所以然，只有这样，才能真正掌握其用法。

PS：文章如有错误，欢迎大家提出意见，一起讨论，共同进步~