Handler完全解读——Handler原理分析

版权声明：欢迎来到我的个人博客：http://blog.N0tExpectErr0r.cn https://blog.csdn.net/qq_21556263/article/details/82759082

Handler完全解读——Handler原理分析

Android为何设计只能通过Handler机制来更新UI呢？

最根本原因：解决多线程并发问题。

比如假设在一个Activity中，有多个线程来更新UI，并且都没有加锁，会发生什么情况呢？

• 界面错乱

那么如果我们对更新UI的操作都进行加锁的话，又会产生怎样的问题？

• 性能下降

基于对上述问题的考虑，Android给我们提供了一套更新UI的机制，我们只需要遵循这样的机制即可。这样就不用去关心多线程问题，更新UI的操作，都是在主线程的Message Queue中去轮询处理的。

Handler与Looper、Message Queue的关系。

Handler

负责发送消息。

Handler封装了消息的发送(包括发送给谁以及如何去发送)，它的内部会与Looper进行关联，在Handler内部可以找到Looper，也就是找到了MessageQueue。

Looper

负责接收Handler发送的消息，并把消息回传给Handler自己。扮演了一个消息承装的载体的角色。

1. Looper内部包含了一个MessageQueue，所有的Handler发送的消息都会走向这个MessageQueue。(将发送的消息在MesageQueue中插入或移出)
2. Looper是通过loop方法来进行对MessageQueue的轮询的。它内部其实就是一个死循环，它会不断从MessageQueue中取出消息。有消息时就取出并处理消息，无消息时就阻塞。

MessageQueue

一个存储消息的容器

MessageQueue实际上就是一个队列，里面可以添加消息，也可以取出消息。

源码分析

预备知识

ActivityThread

在Android的设计中，整个程序都是通过ActivityThread进行创建的。

在ActivityThread中去负责创建我们所有的Activity，并回调Activity的各种方法。并且它会去创建一个线程，也就是我们的主线程。

在主线程中，会为我们创建一个Looper，而在Looper中，又会为我们创建一个MessageQueue。这个MessageQueue就是我们更新UI的Handler发出的Message的走向。

ThreadLocal

ThreadLocal 在我们常见的开发中，一般是在线程中保存一些变量信息。当我们想创建一些与线程相关的变量，就可以通过ThreadLocal。ThreadLocal中有几个方法：

• set方法：将一个变量放入ThreadLocal中。
• get方法：将变量从ThreadLocal中取出。

正式分析

Looper MessageQueue的创建过程

我们查看ActivityThread的源码，可以发现它其实就像普通Java代码一样，有一个main方法。在它的main方法中，我们可以看到这样的一句代码：

Looper.prepareMainLooper();

这个方法的作用其实就是在创建应用程序的过程中，为我们创建Looper对象

我们进入prepareMainLooper方法的源码。

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方法。在prepare方法中。用到了一个sThreadLocal，它是一个ThreadLocal类型的变量，存储的是Looper。

prepare方法在我看来就是用于创建Looper。由于Looper一个线程中只能存在一个，因此需要先判断该线程是否已经存在Looper。如果已经存在Looper，则抛出异常告诉调用者一个线程最多只能有一个Looper。如果其中没有Looper则创建并放入sThreadLocal中。

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的过程中又做了哪些操作呢？

我们查看Looper的构造函数的源码，可以看到，它首先创建了一个MessageQueue，同时将线程设置为当前的线程。

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

Handler与Looper及MessageQueue关联的原理

那么Handler是如何与Looper进行关联的呢？

我们查看Handler的构造函数源码，可以发现，它调用了一个Looper.myLooper()方法为mLooper赋值。

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

查看myLooper方法的源码，可以看到，它实际上就是从sThreadLocal中将Looper取出。

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

拿到这个Looper后，就通过 mQueue = mLooper.mQueue; 将mQueue用该Looper的MessageQueue赋值。拿到MessageQueue以后，就可以通过Handler将Message存到MessageQueue中。

Handler发送消息的原理

研究Handler发送Message的原理，我们可以从sendEmptyMessage方法入手开始研究。

进入sendEmptyMessage方法后，可以看到，它是调用sendEmptyMessageDelayed方法，将延迟时间设置为0来实现的。

public final boolean sendEmptyMessage(int what)
{
    return sendEmptyMessageDelayed(what, 0);
}

跟进sendEmptyMessageDelayed后，可以发现它是通过Message的obtain方法建立了一个空的Message，然后调用sendMessageDelayed方法。

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}

进入sendMessageDelayed方法后，可以看到，它对秒数做了一个判断后，调用了sendMessageAtTime方法，将目前的时间加上延迟秒数计算后传入。(这样就可以算到延迟后的秒数了)

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

我们进入这个方法的源码，可以看到，它会拿到当前线程的MessageQueue，在其不为空的情况下，通过enqueueMessage方法，将Message加入到队列中。

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

Looper的轮询原理

loop方法

之前说到，Looper是通过loop方法来对MessageQueue进行轮询的。在Looper不为空的情况下，获得MessageQueue，之后可以从核心代码for(;;)循环这里开始看。

for(;;)是一个死循环，这就是为什么Looper可以不断地轮询消息队列。它是通过MessageQueue的next方法，从消息队列中取出消息，消息为空的时候，就return，不为空时则调用Message的target的dispatchMessage方法。在dispatchMessage方法中，则会按顺序调用不同的handleMessage方法，达到回调的目的。

/**
 * 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
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }
        final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        final long end;
        try {
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        if (slowDispatchThresholdMs > 0) {
            final long time = end - start;
            if (time > slowDispatchThresholdMs) {
                Slog.w(TAG, "Dispatch took " + time + "ms on "
                        + Thread.currentThread().getName() + ", h=" +
                        msg.target + " cb=" + msg.callback + " msg=" + msg.what);
            }
        }
        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();
    }
}

Handler的dispatchMessage方法

我们来到handler的dispatchMessage方法。可以看到，它会先调用message的callback方法，如果message的callback为空，则调用Handler的Callback中的handleMessage方法。若返回值为true，则return，否则调用它自身的handlerMessage方法。这也就是为什么callback的handleMessage会有截断消息的能力。

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

post与postDelayed的实现

我们回到之前用到的post与postDelayed，分别打开源码。可以看到，post和postDelayed的实现实际上都是通过sendMessageDelayed来实现的，不同点仅仅在于delay秒数的不同。

public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postDelayed(Runnable r, long delayMillis)
{
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

这里在使用时调用了一个getPostMessage函数来获取post对应的Message，查看它的源码后可以发现，它所做的操作其实就是构建了一个Message，并将它的callback指定为post处的Runnable。这样在消息轮询的过程中，Message的callback就会被回调。

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

sendMessage的实现

可以看到，sendMessage同样也是通过调用sendMessageDelayed来实现的。可以发现，handler提供的这几种方法，本质上都是在调用sendMessageDelayed方法。只是为了开发者更方便调用，提供了更多的调用方式而已。

public final boolean sendMessage(Message msg)
{
    return sendMessageDelayed(msg, 0);
}

---

广告时间
我是N0tExpectErr0r，一名广东工业大学的大二学生
欢迎来到我的个人博客，所有文章均在个人博客中同步更新哦
http://blog.N0tExpectErr0r.cn