Android Handler/Looper视角看UI线程的原理

概述

Handler/Looper机制是android系统非重要且基础的机制，即使在rtos或者linux操作系统上开发应用框架时，也经常借鉴这个机制。通过该机制机制可以让一个线程循环处理事件，事件处理逻辑即在Handler的handleMessge种。本文建议android8.1源码分析这套机制的实现原理。

Handler/Looper

Handler：顾名思义，处理消息message的类，Handler也可以发送消息。

Looper：顾名思义，一个循环体，这个循环体本质上就是不断取出Queue种的Message，分发给特定的目标，具体分发给哪个目标要具体情况具体分析。并且Looper内部含有一个Thread对象，很好理解，就是Looper这个循环体是在该线程中执行的。

MessageQueue:消息队列，通过Handler发送的Message加入到该队列中，并且被Looper运行在Thread线程中不断取出，又被Handler执行。

执行流程图：

应用程序使用Looper

应用程序使用Looper分为两种情况，主线程和普通线程：

普通线程

  * <p>This is a typical example of the implementation of a Looper thread,* using the separation of {@link #prepare} and {@link #loop} to create an* initial Handler to communicate with the Looper.**  class LooperThread extends Thread {*      public Handler mHandler;**      public void run() {*          Looper.prepare();**          mHandler = new Handler() {*              public void handleMessage(Message msg) {*                  // process incoming messages here*              }*          };**          Looper.loop();*      }*  }

这段代码在Android源码中非常典型，使用步骤有三：

1. Looper.prepare创建线程私有的Looper对象。
2. 创建处理消息的Handler。
3. Looper.loop开始运作：线程一直循环取消息，处理消息，如果没有消息处理将休眠。

上面代码看似简单，越是简单的代码有时候越是难以理解，我们要理解上面三个步骤是怎么把Thread，MessageQueue，Handler和Looper联系起来的。

Looper.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));}private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();}

可以看到prepare就给调用prepare的当前线程创建一个Looper对象，Looper对象创建的时候，内部新建了MessageQueue和Thread对象，特别注意，mThread是调用prepare的线程。

Handler对象创建

  **          mHandler = new Handler() {*              public void handleMessage(Message msg) {*                  // process incoming messages here*              }*          };

可以想象，这里Handler必须要跟前面prepare创建的Looper产生联系才对，这个就要看Handler的构造函数：

public Handler();
public Handler(Callback callback);
public Handler(Looper looper);
public Handler(Looper looper, Callback callback);

我们要看下上面Handler()构造函数：

    public Handler() {this(null, false);}public Handler(Callback callback, boolean async) {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;}

 可以看到默认构造函数中非常重要的一句，Looper.myLooper，会取得当前线程的Looper对象，也就是Looper.prepare创建的线程私有的对象，同时Handler's MessageQueue来自瑜当前线程Looper's MessageQueue。

注意：Thread和Handler是1：N关系。比如UI线程就可以有多个Handler对象。

Handler发送和处理消息

按照上面分析，调用mHandler可以发送消息，然后处理消息在该Handler的handleMessage函数，我们看看上述流程是如何实现的。

Looper从MessageQueue中取得一个Message后，首先会调用Handler.dispatchMessage进行消息分发，后者再根据具体的策略将Message分发给相应的责任人源码如下：

 Handler.java:

    /*** 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);}}private static void handleCallback(Message message) {                                                                                                  message.callback.run();}

分发策略：

1. Meesage.callback对象不为空优先分发给message.callback。这种情况对应mHandler.post接口发送的runable对象：这种情况下Message.callback就是post的runnable对象

public final boolean post(Runnable r);
public final boolean postAtTime(Runnable r, long uptimeMillis);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;
}

2.  Handler.mCallback不为空，分发给mCallback.handleMessage

3.  前两个都不存在，则调用handleMessage，比如我们当前普通线程场景，override了这个方法，就会调用我们自己Handler.handleMessage。这种情况主要对应是Handler send系列接口使用：

public boolean sendMessageAtTime(Message msg, long uptimeMillis);
public final boolean sendMessageDelayed(Message msg, long delayMillis);比如如下使用：
Message msg = mHandler.obtainMessage();
mHandler.sendMessageAtTime(msg,xxxx);public final Message obtainMessage()                                                                                                                   
{return Message.obtain(this);
}public static Message obtain(Handler h) {Message m = obtain();m.target = h;return m;
}

 可以看到这种情况下Message.target = mHandler，而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...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);}}...msg.recycleUnchecked();}}

 loop循环从Looper's MessageQueue取得消息，然后调用Message.target.dispatchMessage，正如上面的分析Message.target = mHandler，所以调用到了Handler.dispatchMessage方法。

总结：

1. Handler.post(runnable），在Handler.dispatchMessage方法由于优先分发给runnable对象,所以这个runnable对象被执行，而不是Handler.handleMessage。

2. 如果使用sendMessage接口，那么Handler.dispatchMessage分发给Handler override的handleMessage接口，也就是普通线程使用代码中Handler's handleMessage函数。

UI线程

 我们知道ActivityThread是主线程的入口点，我们看看android UI线程中Looper的使用源码：

    public static void main(String[] args) {                                                                                                               Looper.prepareMainLooper();ActivityThread thread = new ActivityThread();thread.attach(false);if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited");}

与普通线程使用Looper类似，也分3个步骤：

1.准备Looper: Looper.prepareMainLooper

2.创建主线程私有的Handler：sMainThreadHandler = thread.getHandler

3.开始工作：Looper.loop

与普通线程的不同点：

1. 普通线程使用Looper.prepare，而主线程需要使用Looper.prepareMainLooper

2.Handler不同：普通线程生成一个与Looper绑定的Handler即可，而主线程是从当前线程总获取

我们分别分析下上面两个不同点

prepareMainLooper

    public static void prepareMainLooper() {                                                                                                               prepare(false);synchronized (Looper.class) {sMainLooper = myLooper();}}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));}

可以看到，prepareMainLooper也使用了prepare，不过参数false代表ui线程不能退出，并且创建的Looper要赋值给sMainLooper，这样其他线程可以通过调用getMainLooper获取该对象。

MainThreadHandler

ActivityThread对象创建时候，会在内部同时生成一个Handler对象：

final H mH = new H()；

thread.getHandler获取的就是该mH，也就是说ActivityThread中主线程处理消息的Handler之一就是该Handler mH。

loop

分析loop函数之前，我们提一下一个图形窗口典型的main函数如下：

main() {initialize()//初始化CreateWindow();//创建窗口ShowWindow();while(GetMessage()) {//不断分发处理DispatchMessage();}
}

那么根据前面loop函数的分析，其实UI线程的loop函数也是在循环中不断取消息，处理消息，符合上述模型。

ViewRootImpl

我们知道ViewRootImpl也属于UI线程的范围，因为ViewRootImpl创建就是在UI线程中创建，那么根据Handler创建的默认构造函数我们知道，这个Handler()这个默认的构造函数，适合当前线程的Looper绑定的，那么ViewRootImpl中Handler()形式构建的Handler也是处理UI线程的相关消息。

final ViewRootHandler mHandler = new ViewRootHandler();final class ViewRootHandler extends Handler {public void handleMessage(Message msg) {switch (msg.what) {case MSG_INVALIDATE:((View) msg.obj).invalidate();break;case MSG_INVALIDATE_RECT:final View.AttachInfo.InvalidateInfo info = (View.AttachInfo.InvalidateInfo) msg.obj;info.target.invalidate(info.left, info.top, info.right, info.bottom);info.recycle();break;case MSG_PROCESS_INPUT_EVENTS:mProcessInputEventsScheduled = false;doProcessInputEvents();break;case MSG_DISPATCH_APP_VISIBILITY:handleAppVisibility(msg.arg1 != 0);break;case MSG_DISPATCH_GET_NEW_SURFACE:handleGetNewSurface();break;....

Choreographer

Choreographer也是工作在UI主线程的一个重要的类，跟Vsync有关，我们通过源码看看这个类为什么工作在UI主线程。

看是否是主线程，我们要看下Choreographer中的Handler/Looper是基于哪个Thread来创建，看下Choreographer的构造函数如下：

private Choreographer(Looper looper, int vsyncSource) {mLooper = looper;mHandler = new FrameHandler(looper);                                                                                                               mDisplayEventReceiver = USE_VSYNC? new FrameDisplayEventReceiver(looper, vsyncSource): null;mLastFrameTimeNanos = Long.MIN_VALUE;mFrameIntervalNanos = (long)(1000000000 / getRefreshRate());mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];for (int i = 0; i <= CALLBACK_LAST; i++) {mCallbackQueues[i] = new CallbackQueue();}}

所以重点就是构建函数中Looper是哪里构建的，Choreographer是个单例类，所以看下其初始化的代码：

    // Thread local storage for the choreographer.private static final ThreadLocal<Choreographer> sThreadInstance =                                                                                      new ThreadLocal<Choreographer>() {@Overrideprotected Choreographer initialValue() {Looper looper = Looper.myLooper();if (looper == null) {throw new IllegalStateException("The current thread must have a looper!");}return new Choreographer(looper, VSYNC_SOURCE_APP);}};

也就是说最终Looper.myLooper获取的是当前线程私有的Looper对象，而Choreographer的getInstance是在public ViewRootImpl(Context context, Display display) 构造函数中调用的，根据ViewRootImpl小节我们知道，ViewRootImpl在主线程构建，所以Choreographer是主线程的

 Vsync信号处理

我们都知道vsync信号处理的实际逻辑是在ui主线程当中，我们看下具体实现，首先要看下vsync信号接受和处理的地方，这个在Choreographer当中：

    private final class FrameDisplayEventReceiver extends DisplayEventReceiverimplements Runnable {private boolean mHavePendingVsync;private long mTimestampNanos;private int mFrame;public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {super(looper, vsyncSource);}@Overridepublic void onVsync(long timestampNanos, int builtInDisplayId, int frame) {...mTimestampNanos = timestampNanos;mFrame = frame;Message msg = Message.obtain(mHandler, this);msg.setAsynchronous(true);mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);}@Overridepublic void run() {mHavePendingVsync = false;doFrame(mTimestampNanos, mFrame);}

可以看到接收到vsync信号之后，使用mHandler向该Handler所在的线程发送消息，根据Choreographer小节我们知道，这里mHandler和其Looper是UI线程的，所以上面代码中发送的消息在主线程中处理，而FrameDisplayEventReceiver是个runnable对象，所以最终主线程收到这消息的处理函数是：doFrame函数:

            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);mFrameInfo.markInputHandlingStart();doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);mFrameInfo.markAnimationsStart();doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);mFrameInfo.markPerformTraversalsStart();doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);

vsync信号过来在主线程处理， 最终处理函数是doFrame->doCallbacks，而doCallbacks就是要处理应用已经请求，且记录到queue里面的各种事件，比如应用请求渲染的时候调用invalidate调用栈：

invalidate() : ViewRootImpl.java--->scheduleTraversals() : ViewRootImpl.java--->mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

最终postCallback的实现：

private void postCallbackDelayedInternal(int callbackType,Object action, Object token, long delayMillis) {synchronized (mLock) {final long now = SystemClock.uptimeMillis();final long dueTime = now + delayMillis;//将要执行的回调封装成CallbackRecord对象，保存到mCallbackQueues数组中mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);//函数执行时间到if (dueTime <= now) {scheduleFrameLocked(now);} else {//通过异步消息方式实现函数延时执行Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);msg.arg1 = callbackType;msg.setAsynchronous(true);mHandler.sendMessageAtTime(msg, dueTime);}}

1.将请求的事件保存在mCallbackQueue，等到vsync信号来到，doFrame中取出执行。

2. 发送MSG_DO_SCHEDULE_CALLBACK消息，最终调用native层的mDisplayEventReceiver.scheduleVsync();请求接收下一次vsync信号