Android Handler消息机制源码分析

---

Handler概述

Android的消息机制主要指的就是Handler的运行机制，Handler的作用是将一个任务切换到指定线程中去执行。在Handler的运行机制中需要MessageQueue和Looper的配合，由这三者共同完成Android的消息机制。

Handler中主要包含：

• Message：消息载体。用于存储具体的消息
• Looper：消息循环器，它不停的从MessageQueue中获取Message，并将消息最终交由Handler处理。
• MessageQueue：消息队列，用于存储Message。
• Handler：主要用于用于发送Message到MessageQueue，并且最终对Message进行处理。

这里可以用一张图来描述：

这里需要明确几个同Handler相关的知识，如下：

为什么需要将一个任务切换到线程中去执行？

这里我们有一个最常见的应用场景，就是Android规定对于UI的操作只能在主线程（也称作“UI线程”）中进行，如果我们在其他子线程中进行UI的相关操作（如调用TextView的setText方法），程序就会抛出异常。因为ViewRootImpl在更新UI前会对当前线程进行判断，如果当前线程不是UI线程就会抛出此异常。

//ViewRootImpl的checkThread方法检查是否是UI线程
void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a view hierarchy can touch its views.");
    }
}

这还有一个疑问，为什么只能在主线程中操作UI呢？

这是因为UI控件不是线程安全的，如果在多个线程中同时操作UI控件可能会因为并发问题产生不可预期的结果。

Looper

Looper的主要作用就是为Thread创建一个消息循环器。具体来说Looper会不停的从MessageQueue中获取Message，如果MessageQueue中有MMessage，那么Looper会将该Message交给Handler处理；否则，Looper会一直阻塞（在下面的源码分析中会具体提到）。

默认情况下，Thread中并没有创建Looper，所以如果想为Thread创建Looper，需要调用Looper.prepare()和Looper.loop()方法，这个在下文的源码分析中会具体说道。

这里可以明确一个结论：如果你想在任意线程（包括UI线程）中使用Handler处理消息，那么就必须为该线程创建一个Looper，否则程序会出现异常。

这里，演示一个为Thread创建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();
      }
}

或许，这里会有一个疑问，我们经常在主线程中使用Handler，此时我们并没有给主线程创建Looper，程序运行也是正常的，这又是为什么呢？
对于这个问题我们不得不提下主线程的ActivityThread类，这里我们主要看下该类的main方法即可，这是主线程的入口。

public static void main(String[] args) {
    ...

    //通过该方法为主线程创建Looper
    Looper.prepareMainLooper();

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

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

    AsyncTask.init();

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

    //开启Looper，不停的从主线程的消息队列中获取消息
    Looper.loop();

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

从上面的代码中可以得出：应用在启动时会为主线程（UI线程）创建默认的Looper，所以在主线程中创建Handler不需要在创建Looper了。

Looper源码分析

public final class Looper {
    /**
     * 创建一个ThreadLocal变量，存储线程的Looper对象
     */
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    /**
     * 主线程Looper
     */
    private static Looper sMainLooper;
    /**
     * 消息队列
     */
    final MessageQueue mQueue;


    /**
     * 创建Looper，一般在子线程中初始化Looper会调用该方法
     */
    public static void prepare() {
        prepare(true);
    }

    /**
     * 创建Looper
     *
     * @param quitAllowed
     */
    private static void prepare(boolean quitAllowed) {
        /**
         *  在为线程创建Looper时，最好能通过myLooper()方法判断当前线程是否存在Looper，避免出现重复创建Looper的异常
         */
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }


    /**
     * 主线中初始化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();
        }
    }

    /**
     * 获取主线程的Looper
     */
    public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }


    /**
     * 该方法是Looper的最主要方法，该方法的作用估计是从当前线程的MessageQueue中获取消息，
     * 如果消息队列中没有消息，该方法会一直阻塞
     */
    public static void loop() {

        // 1、这里首先判断线程中是否存在Looper
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        // 2、获取消息队列
        final MessageQueue queue = me.mQueue;

        // 确保是在本地进程中权限校验
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        // 3、这里是一个死循环，不停的从MessageQueue中获取消息
        for (; ; ) {
            /**
             *
             * 这里调用MessageQueue的next方法，从MessageQueue中获取消息，
             * 如果MessageQueue中没有消息该方法会一直阻塞，这就导致loop方法方法一直阻塞
             */
            Message msg = queue.next(); // 阻塞方法
            if (msg == null) {
                return;
            }

            // 打印日志
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            // 4、这里是将Message交给Handler处理（msg.target是当前线程的Handler对象）
            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

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

    /**
     * 获取当前线程的Looper对象
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

    /**
     * 获取消息队列
     */
    public static MessageQueue myQueue() {
        return myLooper().mQueue;
    }

    /**
     * Looper的构造方法，在该方法中会创建一个MessageQueue，并保存当前线程对象
     */

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

    /**
     * 移除所有的消息(包括消息队列中的)后，退出Looper
     */

    public void quit() {
        mQueue.quit(false);
    }

    /**
     * 移除所有延迟消息（消息队列中的除外）后，退出Looper
     */
    public void quitSafely() {
        mQueue.quit(true);
    }

}

MessageQueue

MessageQueue即消息队列，用于存储消息。
MessageQueue的核心方法是enqueueMessage()和next()。其中enqueueMessage方法用于将将存储到MessageQueue中；next方法用于从MessageQueue中获取消息，如果消息队列中不存在消息该方法会一直阻塞，除非通过Looper的quit方法方可退出阻塞。

MeeesageQueue()

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

enqueueMessage()

MessageQueue是按照Message触发时间的先后顺序排列的，队头的消息是将要最早触发的消息。当有消息需要加入消息队列时，会从队列头开始遍历，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序

/**
 * 存储消息
 */
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) {
        // 退出消息循环，回收Message
        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) {
            // p=null表示MessageQueue为空，将新加入的msg作为MessageQueue的头
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            // 将msg插入到队列的中间。通常情况下，我们不需要唤醒事件队列，除非队列头部有一个障碍，消息是队列中最早的异步消息。
            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;
}

next()

 /**
     * 获取MessageQueue中的消息
     */
    Message next() {

        // 当looper退出时，这里直接返回
        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) {
                        // 当异步的Message还没被触发时，设置超时时间
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        /**
                         * 获取消息队列中的消息
                         */
                        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 android.os.MessageQueue.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 android.os.MessageQueue.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;
        }
    }

quit()

    /**
     * 退出消息循环，也就是退出next方法，一般该方法在Looper中被调用
     */
    void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                /**
                 * 移除延迟的Message
                 */
                removeAllFutureMessagesLocked();
            } else {
                /**
                 * 移除所有的Message
                 */
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }

Handler

Handler，用于发送Message和处理MessageQueue中的消息。

创建Handler

Handler提供了几个Handler的构造方法，如下：

/**
 * 默认构造方法
 */
public Handler() {
    this(null, false);
}

/**
 * 提供回调方法的构造方法
 */
public Handler(Handler.Callback callback) {
    this(callback, false);
}

/**
 * 指定Looper的构造方法
 */
public Handler(Looper looper) {
    this(looper, null, false);
}

/**
 * 指定Looper和回调方法的构造方法
 * @param looper
 * @param callback
 */
public Handler(Looper looper, Handler.Callback callback) {
    this(looper, callback, false);
}


public Handler(boolean async) {
    this(null, async);
}

/**
 * 构造方法
 */
public Handler(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());
        }
    }

    // 1、获取Handler所在线程的Looper对象
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
    }
    // 2、获取Looper中创建的消息队列
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

/**
 * 指定Looper的Handler构造方法
 */
public Handler(Looper looper, Handler.Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

由以上构造方法可知，在Handler的创建过程中，Handler会获取Looper对象并获取Looper对象中创建的MessageQueue。这个很重要，因为通过Handler发送的Message都会被放入到MessageQueue中。

sendMessageAtTime

在Handler中定义了许多post和sendMessage的方法，最终都是调用sendMessageAtTime()方法用于发送消息。

// post一条消息
public final boolean post(Runnable r) {
   return  sendMessageDelayed(getPostMessage(r), 0);
}

// post一条延迟消息
public final boolean postDelayed(Runnable r, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

// 该方法用于在post的一系列方法中封装一个Message对象
private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

// 发送一条消息
public final boolean sendMessage(Message msg){
    return sendMessageDelayed(msg, 0);
}

// 发送一条空消息
public final boolean sendEmptyMessage(int what){
    return sendEmptyMessageDelayed(what, 0);
}

// 发送一条空的延迟消息
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}

// 发送一条定时的空消息
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageAtTime(msg, uptimeMillis);
}

// 发送一条延迟消息
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) {
    // 获取消息队列，该队列就是在Looper初始化的时候创建的
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    // 调用enqueueMessage方法发送消息
    return enqueueMessage(queue, msg, uptimeMillis);
}


/**
 * 该方法将Message发送到MessageQueue中
 */
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }

    //  调用MessageQueue的enqueueMessage方法将消息存储到消息队列中
    return queue.enqueueMessage(msg, uptimeMillis);
}

dispatchMessage()

Handler要想接收消息并对消息进行处理，这需要借助Looper完成，在上文中曾分析了Looper的实现原理，在Looper.next()方法中有一句代码 msg.target.dispatchMessage(msg)，其实msg.target其实就是Handler对象，通过调用Handler的dispatchMessage方法即可对消息进行处理。

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

在该方法中，首先会判断msg.callback是否为空，其实这个callback变量就是通过post方法传入的Runnable对象（如果不调用post相关的几个方法，该参数为空），如果不为空，就调用handleCallback方法，在handleCallback方法中直接回调用Runnable的run方法。

之后，判断mCallback是否为空，mCallback就是Callback的实例，Callback是Handler的一个内部接口。只有在通过new Handler（Callback）创建handler时，mCallback就不为空。

但是，在日常开发中，我们一般不会用上面这种方法，而是通过一个匿名内部类的方式创建一个Handler。如下所示：

private Handler handler = new Handler() {

    @Override
    public void handleMessage(Message msg) {
        // 处理消息
        // ...

    };

};

所以，这里我们可以列出消息分发的优先级：

1. Message的回调方法：message.callback.run()，优先级最高；
2. Handler的回调方法：Handler.mCallback.handleMessage(msg)，优先级仅次于1
3. Handler的默认方法：Handler.handleMessage(msg)，优先级最低。

Message

关于Message的源码就比较简单了，这里主要介绍Message的obtain和recycler方法。

obtain

    /**
     * 从消息池中获取一个Message
     * sPool是一个静态变量，维持着一个消息池
     */
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                // 获取队头的消息，并将消息的头指向下一个
                Message m = sPool;
                sPool = m.next;
                // 讲原来队头的next元素为指向空
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        // 消息池为空创建一个新消息
        return new Message();
    }

recycle

    public void recycle() {
        if (isInUse()) {// 判断消息是否正在被使用
            if (gCheckRecycle) {
                throw new IllegalStateException("This message cannot be recycled because it "
                        + "is still in use.");
            }
            return;
        }
        recycleUnchecked();
    }

    /**
     * 将不用的消息加入消息池sPool
     */
    void recycleUnchecked() {
        // 初始化
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {// 当消息池没有满时，加入
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }