好久没写文章了，刚好最近看了下Android消息机制的源码，上次看通透了，这次再看的时候忘记的差不多了，所以写下来。我将从Handler的使用开始分析Handler，已经与其密不可分的Loop、MessageQueeue、Message。

1. Handler的使用

我们平时使用Handler无外乎就是切换线程，处理延时任务，统一处理业务逻辑。我也在项目中见到通过Handler发送数据到其他类中，这种情况是不推荐使用Handler，应该使用回调。

代码清单1.1是Handler的创建方式

代码清单1.1

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        switch (msg.what) {
            case 1: {
                // ...
            }
            case 2: {
                // ...
            }
        }
    }
};

直接new一个Handler，重写它的handleMessage()方法，在handleMessage()方法中处理发送的message。

当然也有人通过重写dispatchMessage(Message msg)方法处理消息，如代码清单1.2，当然这里不推荐重写这个方法，原因会在后面分析中说明。

代码清单1.2

private Handler mHandler = new Handler() {
    @Override
    public void dispatchMessage(Message msg) {
        super.dispatchMessage(msg);
        switch (msg.what) {
            case 1: {
                // ...
            }
            case 2: {
                // ...
            }
        }
    }
};

上面这种通过重写dispatchMessage(Message msg)方法处理消息，可能大家见过，不推荐使用。不光这个方法，我们平时尽量不要重写系统API中dispatch开头的方法，除非你没有办法不重写，比如：dispatchTouchEnvent()，dispatchKeyEvent()等等，因为系统在dispatchXX()里面做分发的事情，可能因为你注释掉super.dispatch()或者返回true返回false，都会导致一些意想不到的事情发生。

再看看，我们是如何发送消息的？

代码清单1.3

 //方式1 发送/延迟发送 一个空message,所谓的空，指的是message的obj、arg1、arg2是空
 mHandler.sendEmptyMessage(1);
 mHandler.sendEmptyMessageDelayed(1,1000);

 Message msg = Message.obtain();
 msg.what = 1;
 //方式2 这种方式和上面的是一样的
 mHandler.sendMessage(msg);

 msg.obj = "this is message boj.";
 // 方式3
 mHandler.sendMessage(msg);
 // 方式4 发送延时message
 mHandler.sendMessageDelayed(msg, 1000);

 // 方式5 指定时间发送
 mHandler.sendMessageAtTime(msg, SystemClock.uptimeMillis() + 1000);

// 方式6  post Runnable
mHandler.post(new Runnable() {
    @Override
    public void run() {
    }
});

2. Handler发送消息机制

代码清单1.3 是几种发送消息的方式，他们最终都是调用sendMessageAtTime()方法，如代码清单2.1。

代码清单2.1 类Handler.java

public class Handler {
    public final boolean sendEmptyMessage(int what){
        return sendEmptyMessageDelayed(what, 0);
    }
  
    public final boolean post(@NonNull Runnable r) {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
  
    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

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

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

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

可以看到，最终都调用到第27行的sendMessageAtTime()方法，这个方法又调用了enqueueMessage()方法。不用看enqueueMessage()方法，我们也可以猜到，这个方法是向队列MessageQueue中添加数据，实际也确实如此，MessageQueue是一个基于单链表的队列（并且是按照发送时间从小到大排序），队列有两种基本操作：入队 enqueue()，放一个数据到队列尾部；出队 dequeue()，从队列头部取一个元素。

栈也有两种基本操作：入栈 push()和出栈 pop()。

好了，让我们看看enqueueMessage()方法，代码清单2.2。

代码清单2.2 Handler#enqueueMessage()

public class Handler {
        // ...省略其他方法
    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
}

代码清单2.2，第4行msg.target = this;给Message绑定了当前对象Handler，指针指向target（即Handler的引用指向Message的成员变量target）。最后调用了MessageQueue#enqueueMessage()，这个方法是向队列中添加数据。

代码清单2.3 MessageQueue#enqueueMessage()

public final class MessageQueue {

    Message mMessages;
  
    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);
            }
        }
        return true;
    }
}

这个方法比较长，前面是对Message合法性的判断，我们只关注第24到49行，我把他们单独摘出来放在代码清单2.4中，方便你阅读。

代码清单2.4

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

第1行，将类型为Message的成员变量mMessage赋值给临时变量p。mMessage是单链表的一个节点（实际上是单链表的头节点）。

第3行if条件，if(p == null || when == 0 || when < p.when)表示，if(当单链表为空时 || 当前消息的发送时间点是0 || 当前消息的发送时间小于链头消息的时间)，当满足这个条件时，直接讲消息插到链头，5到7行是把消息插入链头的操作。

第9到22行，是一个死循环，退出循环的条件是if (p == null || when < p.when)表示if(已经遍历到最后一个节点 || 消息的时间小于下个节点的时间)，其实就是通过循环找到了，消息插入链表的位置，使得链表按照发送时间升序排序。

单链表结构如下图：

链表.png

代码虽然长了点，但实际实现的就是维护一个图1.1所示的按照when升序排序的单链表，每次插入新的元素都需要保证单链表的有序性，这样当我们发送消息时只需要按照链表的顺序去发送就可以了。

以上就是Message在MessageQueue中的入队操作，我们再看看，出队操作，定义在方法next()中，如代码清单2.5

代码清单2.5 MessageQueue#next()

Message next() {
    // Return here if the message loop has already quit and been disposed.
    // This can happen if the application tries to restart a looper after quit
    // which is not supported.
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    mBlocked = false;
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }
            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {
                dispose();
                return null;
            }
            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }
            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }
        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler
            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }
            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }
        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;
        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

出队的代码也很长，不过我们没有必要细抠每一行。这个方法返回一个Message对象，在代码清单2.5中，我们找return 相关的语句，在第43行。我们还是把关键的一部分逻辑摘出来，方便你阅读。

代码清单2.6 MessageQueue#next()

Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
    // Stalled by a barrier.  Find the next asynchronous message in the queue.
    do {
        prevMsg = msg;
        msg = msg.next;
    } while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
    if (now < msg.when) {
        // Next message is not ready.  Set a timeout to wake up when it is ready.
        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
    } else {
        // Got a message.
        mBlocked = false;
        if (prevMsg != null) {
            prevMsg.next = msg.next;
        } else {
            mMessages = msg.next;
        }
        msg.next = null;
        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
        msg.markInUse();
        return msg;
    }
} else {
    // No more messages.
    nextPollTimeoutMillis = -1;
}

根据之前我们的分析，msg.target是发送这个Message的Handler，如果这个handler是null，就会去获取下一个异步节点。

请注意第2行Message msg = mMessages;第20行mMessages = msg.next;第22行msg.next = null;这三行代码，这是拿到头节点，并且把头节点从链表中摘除，最后返回这个头节点的代码。mMessages代表链表，是链表头节点的引用，第2行将其用临时变量msg保存，相当于msg保存了链表的头节点，第20行将链表的头节点的下一个节点指向当前链表mMessage，第22行，让头节点的下个指针指向null，这样就把头节点从链表mMessage中摘除了。

这块属于链表的操作，讲的可能不是很清除，大家要认真体会。

总结，MessageQueue保存了所有的消息，每次发送消息，将消息添加到了队列的合适位置保证链表按照when从小到大排序，每次去拿消息，都是从链表的头部获取。

3 消息处理机制

我们介绍了消息发送的机制，那么消息是什么时候处理的？以及如何处理的？

以主线程消息处理为例，我们知道ActivityThread的main()方法是应用的入口，main方法中部分代码如下：

代码清单3.1 ActivityThread#main()

public static void main(String[] args) {
  Looper.prepareMainLooper();
  if (false) {
    Looper.myLooper().setMessageLogging(new
            LogPrinter(Log.DEBUG, "ActivityThread"));
    }
    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    Looper.loop();
}

Looper.prepareMainLooper()创建了主线程的Looper对象，并将其存储在常量sThreadLocal中。

代码清单3.2 Looper.java

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

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");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

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

 private Looper(boolean quitAllowed) {
   // Looper的构造方法中会创建MessageQueue
     mQueue = new MessageQueue(quitAllowed);
     mThread = Thread.currentThread();
 }

可以看到，prepare()方法中，第17行用于创建Looper对象，并将Looper对象存在sThreadLocal中，ThreadLocal是以线程为单位存储泛型对象的类，比如线程1给ThreadLocal<Boolean> set一个值false，其他线程通过get()方法依然返回null，只有线程1的get方法会返回false。

代码清单3.1 第9行，Looper.loop()则是开始主线程消息循环，不断从MessageQueue中获取消息，如果MessageQueue中无消息，则会阻塞。代码清单3.3 是Looper的loop()方法。

代码清单3.3 Looper#loop()

public static void loop() {
    final Looper me = myLooper();
    // 省略部分代码
    final MessageQueue queue = me.mQueue;
    boolean slowDeliveryDetected = false;
    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);
        }
        // ...省略部分代码
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        // ...
        try {
            msg.target.dispatchMessage(msg);
            if (observer != null) {
                observer.messageDispatched(token, msg);
            }
            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
        } catch (Exception exception) {
            if (observer != null) {
                observer.dispatchingThrewException(token, msg, exception);
            }
            throw exception;
        } finally {
            ThreadLocalWorkSource.restore(origWorkSource);
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        // ...
        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }
        // 省略部分代码
        msg.recycleUnchecked();
    }
}

第6行表示，loop方法是一个死循环，第7行会调用MessageQueue的next()方法，即从MessageQueue中去拿消息，如果MessageQueue中没有消息，则阻塞。

第24行，msg.target.dispatchMessage(msg);是分发消息，这行是真正的处理消息，关于处理消息机制，下面部分讲解，我们可以看到分发消息前后都有调用logging.printLn()方法，而logging对象我们可以通过setMessageLogging()方法设置，这就给我们提供了一个思路：我们可以通过自定义logging，来获取一次消息处理的耗时时间。

4 处理消息机制

回过头来，我们再看代码清单3.3中第24行的msg.target.dispatchMessage(msg);

前面，我们说了Message的target是发送它的Handler，那么处理消息是从Handler#dispatchMessage()方法开始。

代码清单4.1 Handler#dispatchMessage()

public void dispatchMessage(@NonNull 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();
}

/**
 * Subclasses must implement this to receive messages.
 */
public void handleMessage(@NonNull Message msg) {
}

msg.callback又是什么呢？什么情况下callback!=null

还记得前面我们讲Handler发送消息的几种方式，其中post()方法也是发送消息，如下：

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

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

可见，只有通过post()方法发送消息，callback才被赋值，callback指向Runnable实例。

继续看代码清单4.1，当是通过post()方法发送的消息，则会执行handleCallback(msg);方法，第15行中，handleCallback(msg);方法中会调用Runnable#run()方法，run()方法中就是我们要处理的逻辑。

当是通过sendMessageXXX()方式发送的消息时，会调用handleMessage()方法，源码中这个方法是个空方法。这个方法就是我们创建Handler时重写的方法，用于处理我们自定义的消息。

源码中dispatchMessage和handleMessage()两个方法参数一样，并且都是public类型的方法，都可以被重写。前面我们说不要重写的dispatchMessage()方法，就是因为dispatchMessage()方法内部区分是否是post()的消息。如果使用不当，则会导致Handler#post()方法失效，像下面的代码。

代码清单4.2 演示post()方法失效，实际中不要这么干

private Handler mHandler = new Handler() {
    @Override
    public void dispatchMessage(@NonNull Message msg) {
//          super.dispatchMessage(msg);
        switch (msg.what){
            //处理消息
        }
    }
};

5 子线程中的Handler

前面我们分析，主线程的Looper在ActivityThread的main()方法中初始化，所以我们在主线程可以通过无参的构造器创建Handler。如果在子线程（未初始化Looper）中通过无参的构造器创建Handler，则会抛出RuntimeException，如代码清单5.1，因为子线程未初始化Looper，导致Looper.myLooper();为空。

代码清单5.1 Handler.java

public class Handler {
    public Handler() {
        this(null, false);
    }
  
        public Handler(@Nullable Callback callback, boolean async) {
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
}

那么在子线程中创建Handler是不是可以像代码清单5.2这样。

代码清单5.2 子线程创建Handler

public class Test extends Thread{
    private Handler mHandler;
    @Override
    public void run() {
        super.run();
        Looper.prepare();
        mHandler = new Handler(){
            @Override
            public void handleMessage(@NonNull Message msg) {
                // 处理消息
            }
        };
        Looper.loop();
    }
}

理论上可以这样，不过Android提供了更好的方式，HandlerThread

代码清单5.3 HandlerThread.java

public class HandlerThread extends Thread {
  
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

    @NonNull
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }
}

HandlerThread继承自Thread类的源码很简单，这里不再赘述。

如果我们在需要子线程处理任务，那么只需要执行：

HandlerThread.getThreadHandler().post(new Runnable(){
  // 执行任务
})

但是如果我们想发送消息，在handleMessage()方法中处理消息怎么办？

不知道你有没有注意，Looper的loop()方法中从一开始到消息（Message msg = queue.next();）到分发消息msg.target.dispatchMessage(msg);再到处理消息handleMessage()，中间没有切换线程。这也就是说，handleMessage()在哪个线程中执行，取决于调用loop()所在的线程。

有了这个结论，那么我们创建子线程的Handler是不是可以这样：

    private Handler mHandler;

    private void test() {
        HandlerThread ht = new HandlerThread("thread-id");
        ht.start();
        mHandler = new Handler(ht.getLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                // 处理子线程消息
            }
        };
    }