Android Handler消息机制不完全解析

1.Handler的作用

Android开发中，我们经常使用Handler进行页面的更新。例如我们需要在一个下载任务完成后，去更新我们的UI效果，因为AndroidUI操作不是线程安全的，也就意味着我们不能在非UI线程中去操作UI，否则会抛出CalledFromWrongThreadException异常。

Handler的基本用法：

Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            //do something
        }
    }
};

Handler handler1 = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            //do something
        }
        return false;
    }
});
handler.sendEmptyMessage(1);
handler.post(new Runnable() {
    @Override
    public void run() {

    }
});
...

上面是我们熟悉的Handler的用法，通过几天的源码阅读，今天写下我对Handler的不完全解析吧。为什么说不完全呢？因为能力有限，所以并没有包括native代码的解析。手动滑稽。

---

2.源码不完全解析

提前声明下，这里的解析基本上都是建立在网上查阅资料以及自己源码的理解。如果有问题，请指出。

在这里我们先查看Handler的构造方法。

//无参构造方法
public Handler() {
    this(null, false);
}

//参数为Looper的构造方法
public Handler(Looper looper) {
    this(looper, null, false);
}

//参数为Callback的构造方法
public Handler(Callback callback) {
    this(callback, false);
}

//参数为Looper和Callback的构造方法
public Handler(Looper looper, Callback callback) {
    this(looper, callback, false);
}

从构造方法看，他们竟然后面的都有一个值为false的参数，我们随便看一个构造方法。

/**
* @param callback The callback interface in which to handle messages, or null.
* @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
* each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
*
* @hide
*/
public Handler(Callback callback, boolean async) {
    ...
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        //在子线程中创建Handler的时候会抛出的异常。
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;//把Looper的MessageQueue赋值给Handler的mQuene属性
    mCallback = callback;//Callback赋值
    mAsynchronous = async;//是否为异步的标志
}

看这个方法的对最后一个参数的注释我们可以知道，最后一个参数是是否异步执行的标志，这个方法又是被隐藏的 @hide ，我们无法显示的调用这个构造方法，但是可以通过反射来调用这个构造方法（待测试）。OK，那么我们可以知道，我们所有的构造方法都是同步的，并没有异步执行。

上面的构造方法中包括了一个Looper对象，一个MessageQueue对象，我们来看看这两个到底是什么？什么时候创建的？

先来看看Looper：

public final class Looper {
    private static final String TAG = "Looper";
    // sThreadLocal.get() will return null unless you've called prepare().
    //使用ThreadLocal来确保一个线程中只存在一个Looper
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    private static Looper sMainLooper;  // guarded by Looper.class

    final MessageQueue mQueue;
    final Thread mThread;
    ...
}

我们接着看下 Looper.myLooper() 这个方法：

public static @Nullable Looper myLooper() {
    //直接把sThreadLocal中的Looper对象返回
    return sThreadLocal.get();
}

我们可以看到该方法直接返回当前线程的Looper，如果为null的话，那么抛出了一个异常Can't create handler inside thread that has not called Looper.prepare()，当然啦，我们的Handler在主线程中创建的，所以我们得到的Looper对象一定是不为null的。为什么这么肯定呢？这要从App的启动流程说起（有点扯远了，也是我下个阶段正在看的）。我们知道Android 系统基于Linux的，我们每个App都相当于一个是系统的子进行。举个栗子：我们的Eclipse（好久不用了）中有很多个工程，当我们执行某一个工程的时候就相当于Eclipse给我们的工程创建了一个进程，通过调用工程的入口方法——main()方法来启动。我们App启动也是这个流程，入口在ActivityThread中。我们来看下main()方法：

public static void main(String[] args) {
    ...
    //创建mainLooper。这里mark下，一会要看
    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");
}

我们要注意的是 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();
    }
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    //创建一个Looper，并和当前线程“绑定”
    sThreadLocal.set(new Looper(quitAllowed));
}

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

//ThreadLocal
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

解释下大概意思：创建一个Looper对象，并与当前线程绑定，接下来看下Looper的构造方法:

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

构造方法只是创建了一个MessageQueue对象，这里简单看下MessageQueue的构造方法：

//quitAllowed是否允许停止
MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();//native方法
}

我们这里看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 traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        try {
            //调用Handler的dispatchMessage方法
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }

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

从构造方法可以看出，我们的mainLooper是不允许停止的。看到这里我们要转回去看看我们的Handler sendEmptyMessage 是如何处理的：

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

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();//生成一个Message对象
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}   

public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

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;//这里注意下，把当前Handler对象赋值给target，后面会用到
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

上面的代码也挺简单，执行过程中如果 Message为null 的话，就生成一个Message，把当前Handler赋值给Message对象的target属性，然后调用MessageQueue 的入队方法enqueueMessage：

boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {
        throw new IllegalStateException(msg + " This message is already in use.");
    }

    synchronized (this) {
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            // Inserted within the middle of the queue.  Usually we don't have to wake
            // up the event queue unless there is a barrier at the head of the queue
            // and the message is the earliest asynchronous message in the queue.
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;

            //入队操作，把新的消息放到最后面
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);//唤醒Looper.loop()中的queue.next()，继续执行
        }
    }
    return true;
}

从上面的代码看到，我们的Handler把这条消息放入到MessageQueue的尾部，即先进先出，如果这个队列中没有消息，即当前处于阻塞状态，则唤醒Looper.loop() 中的 queue.next()，继续处理这个消息。我们上面提到了Looper.loop() 这个方法，它是一个死循环，如果当前的消息不为null的时候就去执行msg.target.dispatchMessage(msg)，去处理这个消息：

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            //mCallback的handleMessage方法如果返回true，则不会继续执行handleMessage方法
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

private static void handleCallback(Message message) {
    //这个callback是通过handler.post(new Runnable)方式传递过来的，执行其run()方法
    message.callback.run();
}

public interface Callback {
    public boolean handleMessage(Message msg);
}

public void handleMessage(Message msg) {
}

在处理消息的时候，先判断msg.callback是不是为null，如果不为null，则执行其run()方法，否则判断Callback是否为null，如果不为null则执行Callback 中的 handleMessage方法，并根据其返回值来判断是否执行Hadler的handleMessage方法。 所有的方法都是在当前线程去执行的。

By the way, ViewRootImpl中有一个checkThread()方法，用来判断是不是处于 当前 线程

由于能力有限这里我没有对native方法进行解析，有机会的话再去深入研究下。

---

3.我的理解

简单的说，我认为Looper、Handler就是让当前线程执行当前线程中所有的消息，Handler对象在哪个线程被创建，其消息的执行将会在被创建的那个线程中执行。

基于Handler和Looper的源码，我自己写了一个类似Handler消息机制，便于理解和记忆。源码在GitHub上，欢迎讨论。