Android 深入理解Handler, Looper, Message 三者之间的关系

Handler, Looper, Message三者之间的关系基本上是面试官必问问题之一，那今天让我们从源码的角度来解读一下它们之间的关系

Handler 构造

//主线程创建Handler 
Handler handler = new Handler();

public Handler() {
    this(null, false);
}

public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    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的构造方法，下面我们来分析下两个重点

  mLooper = Looper.myLooper();

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

通过myLooper方法得到一个Looper，sThreadLocal存放的Looper，是主线程main方法中创建的

  mQueue = mLooper.mQueue;

mQueue 为消息队列，是从Looper中获取，接下来看它发送消息的逻辑

Handler 发送消息

 handler.sendMessage(new Message());

  public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 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);
  }

上面代码经过层层调用，最终把消息插入到MessageQueue 队列中（queue队列就是在构造方法中从Looper得到的 ）

//把Hander对象赋值给消息的target 的属性
 msg.target = this;

从构造方法和发送消息可以得出：首先得到主线程创建的Looper对象，然后得到Looper对象中的MessageQueue，然后发送消息到MessageQueue队列当中，插入消息队列以后要如何处理呢？我们来看看Looper的一些方法

Looper prepare方法

主线程在创建的时候会调用Looper的prepare和loop方法，那prepare方法里面干了什么呢？

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对象然后存放到sThreadLocal中，而Handler对象中的Looper就是从sThreadLocal中获取的，接下来看看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();
        }
    }

首先得到looper里的消息队列，然后循环从消息队列里取message，最后调用message里target的dispatchMessage方法，target就是发送消息的Handler对象

 public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
  }

主要看handleMessage方法这行代码，handleMessage需要我们自己去实现，下面这行代码什么时候会调用呢？

 if (msg.callback != null) {
       handleCallback(msg);
  }

这段代码是什么意思呢？这里涉及到发送消息的另外一种方式，我们有时候为了简单会这样调用

 handler.post(new Runnable() {
     @Override
     public void run() {

     }
  })

 //调用的post方法
 public final boolean post(Runnable r)
 {
       return  sendMessageDelayed(getPostMessage(r), 0);
 }

 private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
 }

从getPostMessage方法中可以看到，首先从消息池中得到消息对象，然后把我们创建的Runnable对象赋值给消息的callback属性，我们回过头看看上面的判断代码，判断callback是否为空，不为空调用handleCallback方法

private static void handleCallback(Message message) {
        message.callback.run();
}

方法里面就是回调callback的run方法，run方法就是我们自己的业务逻辑代码

总结

到此三者之间的关系已经分析完毕，主线程在创建时创建Looper对象，在Looper构造方法中创建消息队列MessageQueue，调用Looper的loop方法启动消息循环；然后Handler在创建时从sThreadLocal中取主线程Looper对象中MessageQueue，发送消息插入到消息队列，loop循环取出消息，调用Handler的handleMessage方法或callback回调方法完成消息处理，所以Handler对象必须关联一个Looper对象，在子线程中使用Handler必须要调用Looper的prepare和loop方法，因为它需要Looper的消息队列和消息循环处理，而主线程在创建时已经创建了Looper对象，并启动了Looper循环，所以在主线程中使用Handler不需要调用这2个方法。