Android中的Handler工作原理分析

Handler在Android开发中的使用频率很高，但然最常用的就是有一个耗时任务，在该任务结束后，我们要去更新UI界面，这时自然而然的我们就会使用Handler来完成这个功能。

首先我们在UI线程中实例化一个Handler对象

Handler handler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        String message = (String)msg.obj;
        tvMessage.setText(message);
    }
};

然后我们去新开一个线程执行耗时操作，并通过sendMessage方法返回耗时操作结果

new Thread(new Runnable() {
    @Override
    public void run() {
        //此处可执行耗时操作
        Message message = new Message();
        message.what = 1;
        message.obj = "send message";
        handler.sendMessage(message);
    }
}).start();

返回结果最后会传递到Handler实例的handleMessage这个重载方法中，以供其执行UI更新操作。

以上便是我们常常使用Hanlder的常规方法了，这里我们有疑惑了

疑惑1、Handler实例的handleMessage是否总是在UI线程中执行的
疑惑2、我们在异步线程中通过sendMessage发送的消息是如何传递到handleMessage这个方法中去的

实际上我们常常还会通过在UI线程中实例化一个Hanlder对象，然后在异步线程中通过如下代码使用Handler实例化对象更新UI界面。

new Handler().post(new Runnable() {
    @Override
    public void run() {
        tvMessage.setText("post Message");
    }
});

很明显这里的run方法是在UI线程中执行的，这里就引出另一个疑惑
疑惑3、这个Handler的实例对象怎么通过post方法切换了异步线程到了UI线程

而本篇博客在分析Handler工作原理后讲揭晓这三个疑惑的神秘面纱。

1、Handler的作用说明

我们经常使用Handler都是，通过其来讲耗时的异步线程操作数据传递到UI线程中来更新UI，但是实际上这个不是Handler的作用的全部，实际上Handler的主要作用是将一个任务切换到某个指定线程中去执行，也就是这里指出来了，Handler的主要作用实际上不是切换到UI线程而是可以切换到任何线程，而这里先提前指出切换到的线程时Handler对象实例所在的线程。

也就是说上面的重载handleMessage方法，如果Handler实例是在UI线程中，那么该重载方法就是在UI线程中执行，如果不在UI线程中，那么handleMessage方法就会在另外的Handler实例化的对应线程中去执行（这时当然也就无法更新UIj界面了），这个对上面的run方法也是如此，所以我们不能先入为主的认为handleMessage方法就一定是在UI线程中执行的。

2、ThreadLocal的介绍

为什么好好的讲Handler怎么就切到ThreadLocal了呢，这又是个什么鬼？ 因为后面要讲Handler、MessageQueue、Looper以及Message这几者之间关系时会用到ThreadLocal，所以这里就提前拿出来说说这个类到底能做什么事情。

具体到ThreadLocal的使用场景，一般来说，当数据的作用域就是线程且不同线程具有不同的数据副本的时候，这时就可以考虑采用ThreadLocal了。看了这句话可能还是对ThreadLocal很模糊，下面就举一个例子来说明

首先，定义一个TreadLocal的对象

private TreadLocal<Boolean> mBooleanThreadLocal = new TreadLocal<Boolean>();

然后分别在主线程，子线程1和子线程2中设置和访问它的值，代码如下

mBooleanThreadLocal.set(true);
Log.d(TAG,"[Thread#main]mBooleanThreadLocal=" + mBooleanThreadLocal.get());

new Thread("Thread#1"){
    @Override
    public void run() {
        mBooleanThreadLocal.set(false);
        Log.d(TAG,"[Thread#1]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
    }
}.start();

new Thread("Thread#2"){
    @Override
    public void run() {
        Log.d(TAG,"[Thread#2]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
    }
}.start();

输出的结果为

D/HandlerActivty(8576): [Thread#main]mBooleanThreadLocal=true
D/HandlerActivty(8576): [Thread#1]mBooleanThreadLocal=false
D/HandlerActivty(8576): [Thread#2]mBooleanThreadLocal=null

这里我们看到同一个ThreadLocal实例在不同线程中的set/get方法相互之间互不影响，这个小节我们知道ThreadLocal的这个特性就好了，具体怎么实现的这篇博文不深究，感兴趣的同学可以自行研究。

3、Handler、MessageQueue、Looper以及Message的关系

好了，这一小节好像终于要切到正题上了，实际上我们应该知道一个大概，MessageQueue是用来存储Message对象的，而Looper是不断从MessageQueue中获取Message，然后传递消息到Handler以便Handler进行操作。

3.1、MessageQueue中如何存储Message

那么这里MessageQueue如果获取Message消息的呢，实际上是通过Handler实例的sendMessage来获取的

研究源码可知，senMessage方法会调用到Handler的如下sendMessageAtTime方法中

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

我们看到sendMessageAtTime中有一个enqueueMessage方法

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

这个方法中我们要注意msg.target = this这行代码，这行代码将压入MessageQueue对象的Message实例的target指向了当前Handler对象。

最后通过queue.enqueueMessage(msg, uptimeMillis)方法将Message压入了MessageQueue中，实际上我们去MessageQueue中去看对应的enqueueMessage方法会发现，我去，所以得MessageQueue居然不是以队列的数据结构存储Message，而是以单向数据链表来存储的Message。到这里就知道了MessageQueue如何获取到Message了。

3.2、Handler实例化之前必须实例化Looper对象

回头再看看3.1小节中的sendMessageAtTime方法的第一行代码

MessageQueue queue = mQueue;

这里的Handler对象的mQueue属性是什么时候实例化的呢？这里就要引出使用Hanler的另一条原则了

在一线程中实例化Handler之前，必须先实例化Looper对象，且一个线程中有且只有一个Looper对象

我么可以看Hander的构造函数

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

这里构造函数中有一行代码

mQueue = mLooper.mQueue;

这个说明了在实例化Handler之前必须有Looper的实例化对象，这里可以通过Looper.prepare来实例化Looper对象

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

这里可以看到prepare方法通过我们上面介绍的ThreadLocal的set方法在当前线程中实例化并存储了一个Looper对象，而且从代码还可以看到prepare方法执行时，如果ThreadLocal.get中已经有Looper实例的话就会报错，所以一个线程中只能有一个Looper对象。

再看Handler的构造方法有获取Looper对象的代码

mLooper = Looper.myLooper();

跟进去发现，还是ThreadLocal的get方法来获取prepare方法中存储的当前线程中的Looper对象

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

到这里应该讲清楚了，为何实例化Handler之前需要实例化Looper对象，且一个线程中只能有一个Looper对象。

3.3、Looper提取MessageQueue中的消息并传递给Handler处理

上面讲了实例化Hanlder之前要调用Looper.prepare方法，实际上在当前线程中还必须调用Looper.loop方法，来开启Looper对象死循环查看MessageQueue中是否有Message，并及时传递给Handler处理

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare();
        testHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Looper.myLooper().quit();
            }
        };
        Looper.loop();
    }
}).start();

实际上，这里Looper.loop方法，在实例化Handler之前还是之后调用并没有什么影响，下面来看卡Looper.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();
    }
}

代码中可以看到由for语句组成的一个死循环，for语句中的第一行代码就是

Message msg = queue.next(); // might block

这行代码是从MessageQueue中获取Message消息，注意MessageQueue的next方法是一个阻塞方法，当其中没有Message时，loop方法也会在这里被阻塞。获取到Message消息后会执行

msg.target.dispatchMessage(msg);

这里的msg.target如我们3.1小节提示的那样，指向了sendMessage时对应的Handler对象，这也说明了尽管一个线程中只有一个Looper对象，但是一个线程中存在多个Handler时，该Looper对象还是可以应付的过来，就是因为压入MessageQueue的Message对象的target属性可以区分不同的Handler。

而这里的msg.target.dispatchMessage(msg)便将对象的Message对象传递到了Handler进行处理，同时我们注意到实际在这里也就完成了线程的转移，我们在一个线程中传递Message，而在另一个线程(Handler实例化线程)中dispatchMessage。

3.4、Handler中处理Message

在3.3小节我们提到了handler中通过dispatchMessage来处理Message，这里我们便来看看对应的处理代码

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

咦，怎么这里有个msg.callback对象，这个对象是哪儿来的？实际上我们前面说了，还有post方式使用Handler

new Handler().post(new Runnable() {
    @Override
    public void run() {
        tvMessage.setText("post Message");
    }
});

而这里的msg.callback就是这里的Runnable对象了，怎么看出来的呢？我们看这里的post方法

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

其中又调用了getPostMessage的方法

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

于是乎msg.callback就是post方法中的Runnable对象了，而dispatchMessage中的mCallback又是什么鬼呢？我们再来看看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) {
            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;
}

所以这里的mCallback就是实例化Handler时的Callback实例对象，当然我们没串的话也就是null了。所以当msg.callback以及mCallback都为null的时候，dispatchMessage也就调用重载的handleMessage方法。

4、UI线程中使用Handler为何没有Looper.prepare以及Looper.loop

实际上，这个问题很简单。Android主线程就是ActivityThread，主线程的入口方法为main，在main方法中通过Looper.prepareMainLooper方法来创建Looper实例对象，另外也会通过Looper来开启死循环遍历，代码如下

public static void main(String[] args) {
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
    SamplingProfilerIntegration.start();

    // CloseGuard defaults to true and can be quite spammy.  We
    // disable it here, but selectively enable it later (via
    // StrictMode) on debug builds, but using DropBox, not logs.
    CloseGuard.setEnabled(false);

    Environment.initForCurrentUser();

    // Set the reporter for event logging in libcore
    EventLogger.setReporter(new EventLoggingReporter());

    // Make sure TrustedCertificateStore looks in the right place for CA certificates
    final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
    TrustedCertificateStore.setDefaultUserDirectory(configDir);

    Process.setArgV0("<pre-initialized>");

    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }

    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

我想通过以上的介绍，童鞋们应该能够自己回答文章开头所提出来的那三个疑问了，写文章的时间有点紧，难免疏漏，所以有发现bug的同学还望指正，谢谢！