Handler ,Looper , Message , MessageQueue的调度原理

心已赠人 2022-07-12 07:12 210阅读 0赞

### 一、Handler机制工作流程 ###

Android的消息机制主要是指Handler的运行机制，Handler的运行需要底层的MessageQueue和Looper的支撑，MessageQueue是指消息队列，它的内部存储了一组消息，以队列的形式对外提供插入和删除工作，它的内部存储结构并不是真正的队列，而是采用单链表的数据结构来存储消息列表。Looper是消息循环，由于MessageQueue只是一个消息的存储单元，它不能去处理消息，而Looper填补了这个功能，Looper会以无限循环的形式去查询是否有新消息，有的话就处理消息，否则就一直等待着，Looper中还有一个特殊的概念-ThreadLocal，ThreadLocal并不是线程，它的作用是可以在每个线程中存储数据，Handler创建的时候会采用当前线程的Looper来构造消息循环系统，那么Handler内部就是用ThreadLocal来获取当前线程的Looper的。需注意的是线程默认是没有Looper的，如果需要使用Handler就必须为线程创建Looper，我们所说的主线程（UI线程）就是ActivityThread，它在被创建的时候会初始化Looper，所以主线程默认可以使用Handler了。

### 二、Handler消息机制原理深入剖析 ###

#### 1.MessageQueue的工作原理 ####

MessageQueue主要包含两个操作，插入和读取，读取操作本身会伴随着删除操作，插入和读取对应的方法分别为enqueueMessage和next，其中enqueueMessage是往消息队列中插入一条消息，而next的作用是从消息队列中取出一条消息并将其从消息队列中移除，下面分析下enqueueMessage和next方法的源码：

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

enqueueMessage主要操作其实就是单链表的插入操作，  
下面来看一下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;
 }
 
 ...
 }
 
 ...
 }
 }

可以看出next方法是一个无限循环的方法，如果消息队列中没有消息，那么next的方法会一直阻塞在这里，当有新信息来时，next方法会返回这条消息并将其从单链表移除。

#### 2.Looper的工作原理、 ####

Looper会不停地从MessageQueue中查看是否有新消息，如果有新消息就会立刻处理，否则就一直阻塞在那里。

public final class Looper {
 
 /*
 * API Implementation Note:
 *
 * This class contains the code required to set up and manage an event loop
 * based on MessageQueue. APIs that affect the state of the queue should be
 * defined on MessageQueue or Handler rather than on Looper itself. For example,
 * idle handlers and sync barriers are defined on the queue whereas preparing the
 * thread, looping, and quitting are defined on the looper.
 */
 
 private static final String TAG = "Looper";
 
 // sThreadLocal.get() will return null unless you've called prepare().
 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
 private static Looper sMainLooper; // guarded by Looper.class
 
 final MessageQueue mQueue;
 final Thread mThread;
 
 private Printer mLogging;
 private long mTraceTag;
 
 /** Initialize the current thread as a looper.
 * This gives you a chance to create handlers that then reference
 * this looper, before actually starting the loop. Be sure to call
 * {@link #loop()} after calling this method, and end it by calling
 * {@link #quit()}.
 */
 public static void prepare() {
 prepare(true);
 }
 
 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));
 }
 
 /**
 * Initialize the current thread as a looper, marking it as an
 * application's main looper. The main looper for your application
 * is created by the Android environment, so you should never need
 * to call this function yourself. See also: {@link #prepare()}
 */
 public static void prepareMainLooper() {
 prepare(false);
 synchronized (Looper.class) {
 if (sMainLooper != null) {
 throw new IllegalStateException("The main Looper has already been prepared.");
 }
 sMainLooper = myLooper();
 }
 }
 
 /**
 * Returns the application's main looper, which lives in the main thread of the application.
 */
 public static Looper getMainLooper() {
 synchronized (Looper.class) {
 return sMainLooper;
 }
 }
 
 /**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the 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.traceBegin(traceTag, msg.target.getTraceName(msg));
 }
 try {
 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();
 }
 }
 
 /**
 * Return the Looper object associated with the current thread. Returns
 * null if the calling thread is not associated with a Looper.
 */
 public static @Nullable Looper myLooper() {
 return sThreadLocal.get();
 }
 
 /**
 * Return the {@link MessageQueue} object associated with the current
 * thread. This must be called from a thread running a Looper, or a
 * NullPointerException will be thrown.
 */
 public static @NonNull MessageQueue myQueue() {
 return myLooper().mQueue;
 }
 
 private Looper(boolean quitAllowed) {
 mQueue = new MessageQueue(quitAllowed);
 mThread = Thread.currentThread();
 }
 
 /**
 * Returns true if the current thread is this looper's thread.
 */
 public boolean isCurrentThread() {
 return Thread.currentThread() == mThread;
 }
 
 /**
 * Control logging of messages as they are processed by this Looper. If
 * enabled, a log message will be written to <var>printer</var>
 * at the beginning and ending of each message dispatch, identifying the
 * target Handler and message contents.
 *
 * @param printer A Printer object that will receive log messages, or
 * null to disable message logging.
 */
 public void setMessageLogging(@Nullable Printer printer) {
 mLogging = printer;
 }
 
 /** {@hide} */
 public void setTraceTag(long traceTag) {
 mTraceTag = traceTag;
 }
 
 /**
 * Quits the looper.
 * 
 * Causes the {@link #loop} method to terminate without processing any
 * more messages in the message queue.
 * 
 * Any attempt to post messages to the queue after the looper is asked to quit will fail.
 * For example, the {@link Handler#sendMessage(Message)} method will return false.
 * 
 * Using this method may be unsafe because some messages may not be delivered
 * before the looper terminates. Consider using {@link #quitSafely} instead to ensure
 * that all pending work is completed in an orderly manner.
 * 
 *
 * @see #quitSafely
 */
 public void quit() {
 mQueue.quit(false);
 }
 
 /**
 * Quits the looper safely.
 * 
 * Causes the {@link #loop} method to terminate as soon as all remaining messages
 * in the message queue that are already due to be delivered have been handled.
 * However pending delayed messages with due times in the future will not be
 * delivered before the loop terminates.
 * 
 * Any attempt to post messages to the queue after the looper is asked to quit will fail.
 * For example, the {@link Handler#sendMessage(Message)} method will return false.
 * 
 */
 public void quitSafely() {
 mQueue.quit(true);
 }
 
 /**
 * Gets the Thread associated with this Looper.
 *
 * @return The looper's thread.
 */
 public @NonNull Thread getThread() {
 return mThread;
 }
 
 /**
 * Gets this looper's message queue.
 *
 * @return The looper's message queue.
 */
 public @NonNull MessageQueue getQueue() {
 return mQueue;
 }
 
 /**
 * Dumps the state of the looper for debugging purposes.
 *
 * @param pw A printer to receive the contents of the dump.
 * @param prefix A prefix to prepend to each line which is printed.
 */
 public void dump(@NonNull Printer pw, @NonNull String prefix) {
 pw.println(prefix + toString());
 mQueue.dump(pw, prefix + " ");
 }
 
 @Override
 public String toString() {
 return "Looper (" + mThread.getName() + ", tid " + mThread.getId()
 + ") {" + Integer.toHexString(System.identityHashCode(this)) + "}";
 }
 }

在它的构造方法中

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

会创建一个MessageQueue消息队列，然后将当前的线程对象保存起来。  
Looper.prepare（）方法可以为当前线程创建一个Looper，然后再调用Looper.loop（）即可开启消息轮询。

Looper除了prepare方法外，还提供了prepareMainLooper方法，这个方法主要是给主线程也就是AcitivityThread创建Looper使用的，其本质也是通过prepare方法来实现，由于主线程Looper比较特殊，所以Looper提供了一个getMainLooper方法，通过它可以在任何地方获取到主线程的Looper，Looper提供了quit和quitSafely来退出一个Looper，二者的区别是：quit会直接退出Looper，而quitSafely只是设定一个退出标记，然后把消息队列中的已有消息处理完毕后才安全退出。  
Looper退出后，通过Handler发送的消息会失败，这个时候Handler的send方法会返回false。在子线程中，如果手动为其创建了Looper，那么在所有的事情完成以后应该调用quit方法来中止消息循环，否则子线程会一直处于等待的状态，

Looper最重要的方法是loop方法，只有调用了loop方法后，消息循环系统才会真正的其作用，  
loop方法是一个for的死循环，跳出循环的方式是MessageQueue的next方法返回了null，当Looper的quit方法被调用时，Looper就会调用MessageQueue的quit或者quitSafely方法来通知消息队列退出，当消息队列被标记为退出状态时，它的next方法就会返回null。也就是说Loooper必须退出，否则loop方法就会循环下去，loop方法会调用MessageQueue的next来获取新信息，而next是一个阻塞操作，当没有消息时，next方法会一直阻塞在那里，导致loop方法也一直阻塞。  
当有消息到来时，就会调用dispatchMessage方法来处理，但handler的dispatchMessage方法是在创建Handler所使用的Looper中执行的，这样就达到了切换线程执行的目的了。

#### Handler工作原理 ####

Handler关键方法：

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) {
 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;
 if (mAsynchronous) {
 msg.setAsynchronous(true);
 }
 return queue.enqueueMessage(msg, uptimeMillis);
 }
 
 
 
 public final boolean sendMessageAtFrontOfQueue(Message msg) {
 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, 0);
 }

可以看出，Handler发送消息的过程仅仅是向消息队列中插入一条消息，MessageQueue的next方法就会返回这条消息给Looper，最终Looper交由Handler处理，即Handler的dispatchMessage方法会被调用，

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

从以上代码可以看出，说如果Message的callback不为null，则通过handleCallback方法来处理消息，Message的callback是一个Runnable对象，实际上就是Handler的post方法所传递的Runnable参数,

private static void handleCallback(Message message) {
            message.callback.run();
        }

若Message的callback为空，则检查mCallback是否为null，不为null则调用mCallback的handleMessage方法。

Callback是个接口，通过Callback，可以通过Handler handler = new Handler(callback),即可以不需要通过派生Handler子类来创建一个Handler实例，给我们提供了另外一种使用Handler的方式。

最后，调用Hanlder的handleMessage方法来处理消息。

参考资料：《Android开发艺术探索》