源碼分析Handler+Looper+MessageQueue消息模型

源碼分析Handler消息模型

Handler

職責

從開發者角度來看，可分爲

• Message的發送者
• Message的處理者
• Message的移除者

首先我們老看Handler的成員變量

public class Handler {
    @UnsupportedAppUsage
    final Looper mLooper;//當前線程對應的Looper對象
    final MessageQueue mQueue;//Looper裏維護的對應MessageQueue
    @UnsupportedAppUsage
    final Callback mCallback;//當message沒有callback的時候，會判斷走當前的Callback回調
    final boolean mAsynchronous;//是否是異步執行
    @UnsupportedAppUsage
    IMessenger mMessenger;//用於跨進程發送消息
}

//Handler.java
public class Handler {
    public Handler(@Nullable Callback callback, boolean async) {
            //爲false，用於檢測是否是弱引用或者靜態變量，檢測內存泄露
            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());
                }
            }
            //創建當前線程Looper
            mLooper = Looper.myLooper();
            if (mLooper == null) {
                throw new RuntimeException(
                    "Can't create handler inside thread " + Thread.currentThread()
                            + " that has not called Looper.prepare()");
            }
            //從Looper中取出MessageQueue
            mQueue = mLooper.mQueue;
            //回調賦值
            mCallback = callback;
            //是否異步
            mAsynchronous = async;
        }
}

    //Looper.java
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();//從當前線程中獲取對應Looper，具體Looper後面詳細講解
    }

1.Message的發送者

    
public class Handler{

    //發送消息
    public final boolean sendMessage(@NonNull Message msg) {
        return sendMessageDelayed(msg, 0);//執行延時爲0的發送
    }

    //發送延遲處理消息
    public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
        if (delayMillis < 0) {//容錯判斷
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);//發送相對於當前時間的任務消息
    }

    public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
        //難道構造函數中獲取的MessageQueue
        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(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;//將當前Handler對象賦值給Message的target
        msg.workSourceUid = ThreadLocalWorkSource.getUid();//返回該線程當前執行的代碼的UID。

        //設置異步執行
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //交由MessageQueue處理具體的隊列邏輯
        return queue.enqueueMessage(msg, uptimeMillis);
    }
}


//MessageQueue.java
public final class MessageQueue{

    boolean enqueueMessage(Message msg, long when) {
            //hanler爲null，拋出異常
            if (msg.target == null) {
                throw new IllegalArgumentException("Message must have a target.");
            }
            //相同message已經被處理，拋出異常
            if (msg.isInUse()) {
                throw new IllegalStateException(msg + " This message is already in use.");
            }

            synchronized (this) {
                //調用了quit方法取消終止循環，就return掉
                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;
                }
                //更改Message使用標記
                msg.markInUse();
                //更新執行時間值
                msg.when = when;
                //當前MessageQueue的Message鏈表
                Message p = mMessages;
                //需要喚醒
                boolean needWake;
                //如果當前Messages沒有 || 立即執行 || 當前時間比Message鏈表頭結點時間更短,則將當前節點作爲第一個結點加入
                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;
                    //根據when尋找插入位置並插入
                    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;
                }

                // 我們可以假設mPtr！= 0，因爲mQuitting爲false。
                if (needWake) {
                    //native方法喚醒時間隊列
                    nativeWake(mPtr);
                }
            }
            return true;
    }
        
}

上面小節介紹的是Handler作爲發送者的具體做的事情，Handler通過sendMessage等其他方法將消息Message加入MessageQueue裏面的消息鏈表裏

2.Message的處理者

再Looper.loop()中循環取消息調用msg.target.dispatchMessage(msg);來處理時間，其中的target有講過，是對應當前的Handler對象，所以我們來看dispatchMessage(msg)方法

public class Handler{

    //處理消息 
    public void dispatchMessage(@NonNull Message msg) {
        //如果message中設置了callback，則回調callback。
        //callback是通過post方法發送消息賦值的
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            //如果成員變量mCallback已設置，則回調mCallback.handleMessage處理
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //如果上面都沒有，使用handleMessage處理消息，該方法是一個空實現，需要使用者重寫
            handleMessage(msg);
        }
    }

    //子類必須實現
    public void handleMessage(@NonNull Message msg) {
    }
}

所以Handler也是消息的處理者，是消息的入口與出口，這樣的設計讓我們在使用時無需關心Looper和MessageQueue詳細細節是怎麼處理的，同時可以有多個handler來向消息隊列里加入消息並處理，方便在各個地方使用。

3.Message的移除者

三個方法都是調用MessageQueue對應的remove方法

public class Handler{
    public final void removeMessages(int what) {
        mQueue.removeMessages(this, what, null);
    }

    public final void removeMessages(int what, @Nullable Object object) {
        mQueue.removeMessages(this, what, object);
    }

    public final void removeCallbacksAndMessages(@Nullable Object token) {
        mQueue.removeCallbacksAndMessages(this, token);
    }

}

都是調用MessageQueue來移除隊列

Looper

職責

負責無限循環從MessageQueue中取出消息

Looper的創建

Looper是私有構造函數，所以需要使用Looper.prepare來創建Looper對象

public final class Looper {

    //Looper是一個私有的構造函數，在裏面創建了MessageQueue隊列和獲取當前線程
    private Looper(boolean quitAllowed) {
        //獲取當前線程，參數quitAllowed，主線程不能退出傳的false，子線程傳的true
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

    //無參方法，創建一個允許退出的Looper
    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        //sThreadLocal是一個存儲Looper的線程對象，重複創建Looper對象，則拋錯
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //創建Looper對象並設置給sThreadLocal
        sThreadLocal.set(new Looper(quitAllowed));
    }

    //創建主線程Looper
    public static void prepareMainLooper() {
        //主線程不允許退出，所以傳false
        prepare(false);
        synchronized (Looper.class) {
            //成員變量保存主線程Looper，重複創建拋出異常
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            //從sThreadLocal獲取Looper，賦值成員變量
            sMainLooper = myLooper();
        }
    }

    //獲取當前線程Looper
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

}

Looper循環

Looper顧名思義，是用來循環的，其中具體操作在loop()方法中

public final class Looper {

    /**
      * 在此線程中運行消息隊列。 確保調用{@link #quit（）}以結束循環
      **/ 
    public static void loop() {
        //獲取當前線程Looper
        final Looper me = myLooper();
        //未調用prepare創建，拋出異常
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //獲取到Looper中創建的消息隊列
        final MessageQueue queue = me.mQueue;

        //確保此線程的身份是本地進程的身份，並跟蹤該身份令牌實際上是什麼.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        // 允許使用系統屬性覆蓋閾值。例如
        // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
        final int thresholdOverride =
                SystemProperties.getInt("log.looper."
                        + Process.myUid() + "."
                        + Thread.currentThread().getName()
                        + ".slow", 0);

        //標誌是否緩慢
        boolean slowDeliveryDetected = false;

        //開始無限循環取出消息
        for (;;) {
            // 可能阻塞，具體去取出消息，在後續MessageQueue中講解
            Message msg = queue.next(); 
            if (msg == null) {
                // 沒有消息表示消息隊列正在退出。
                return;
            }

            // 如果UI事件設置了記錄器，則必須在局部變量中
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            // 確保觀察者在處理交易時不會改變,可以通過set方法監聽
            final Observer observer = sObserver;

            //獲取到緩慢或發送日誌的閾值
            final long traceTag = me.mTraceTag;
            long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
            long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
            if (thresholdOverride > 0) {
                slowDispatchThresholdMs = thresholdOverride;
                slowDeliveryThresholdMs = thresholdOverride;
            }
            //都大於0,則緩慢發送
            final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
            //分發閾值大於0，則日誌緩慢分發
            final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

            //如果是緩慢發送，則需要記錄開始時間
            final boolean needStartTime = logSlowDelivery || logSlowDispatch;
            //如果緩慢分發，則需要記錄結束時間
            final boolean needEndTime = logSlowDispatch;

            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }

            //分發開始時間
            final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
            final long dispatchEnd;
            Object token = null;
            //告訴觀察者開始分發立即調用
            if (observer != null) {
                token = observer.messageDispatchStarting();
            }
            //設置消息資源Uid   
            long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
            try {
                //實際交由消息對應Hander的dispatchMessage處理
                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 (logSlowDelivery) {
                if (slowDeliveryDetected) {
                    if ((dispatchStart - msg.when) <= 10) {
                        Slog.w(TAG, "Drained");
                        slowDeliveryDetected = false;
                    }
                } else {
                    if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                            msg)) {
                        // Once we write a slow delivery log, suppress until the queue drains.
                        slowDeliveryDetected = true;
                    }
                }
            }
            if (logSlowDispatch) {
                showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", 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);
            }
            //回收message,主要是重置成員變量值並加入消息池，方便後續繼續複用該Message 
            msg.recycleUnchecked();
        }
    }
}

MessageQueue

職責

使用鏈表存儲消息

構造函數和部分成員變量

//MessageQueue.java
public final class MessageQueue {

    //是否允許退出
    private final boolean mQuitAllowed;

    //當前消息，數據結構是鏈表
    Message mMessages;

    //是否正在推出
    private boolean mQuitting;

    // 指示next()是否被阻止在pollOnce()中以非零超時等待
    private boolean mBlocked;


    MessageQueue(boolean quitAllowed) {
        mQuitAllowed = quitAllowed;
        //過native方法初始化消息隊列，其中mPtr是供native代碼使用
        mPtr = nativeInit();
    }   
}

//native代碼
static void android_os_MessageQueue_nativeInit(JNIEnv* env, jobject obj) { 
    //創建出MessageQueue對象
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue(); 
    //未能創建成功拋出異常
    if (!nativeMessageQueue) { 
       jniThrowRuntimeException(env, "Unable to allocate native queue"); 
       return;
       }
    //添加強引用指針
    nativeMessageQueue->incStrong(env); 
    //設置messageQueue
    android_os_MessageQueue_setNativeMessageQueue(env, obj, nativeMessageQueue);
} 

static void android_os_MessageQueue_setNativeMessageQueue(JNIEnv* env, jobject messageQueueObj,
       NativeMessageQueue* nativeMessageQueue) { 
    //將隊列地址設置保存在mPtr中
    env->SetIntField(messageQueueObj, gMessageQueueClassInfo.mPtr, 
    reinterpret_cast<jint>(nativeMessageQueue)); 
 }

//創建nativeMessageQueue
NativeMessageQueue::NativeMessageQueue() : mInCallback(false), mExceptionObj(NULL) { 
    //獲取到線程對應Looper
    mLooper = Looper::getForThread();
    //如果未創建，則創建Looper並設置進線程中
    if (mLooper == NULL) {
      mLooper = new Looper(false);
      Looper::setForThread(mLooper); 
    }
}

消息入隊列

Handler獲取的MessageQueue調用了enqueueMessage方法將消息入隊列，已經在上面的Handler中講解了，這裏再列舉一遍

public final class MessageQueue {
        
    boolean enqueueMessage(Message msg, long when) {
            //hanler爲null，拋出異常
            if (msg.target == null) {
                throw new IllegalArgumentException("Message must have a target.");
            }
            //相同message已經被處理，拋出異常
            if (msg.isInUse()) {
                throw new IllegalStateException(msg + " This message is already in use.");
            }

            synchronized (this) {
                //調用了quit方法取消終止循環，就return掉
                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;
                //當前MessageQueue的Message鏈表
                Message p = mMessages;
                //需要喚醒
                boolean needWake;
                //如果當前Messages沒有 || 立即執行 || 當前時間比Message鏈表頭結點時間更短,則將當前節點作爲第一個結點加入
                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;
                    //根據when尋找插入位置並插入
                    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;
                }

                // 我們可以假設mPtr！= 0，因爲mQuitting爲false。
                if (needWake) {
                    //native方法喚醒時間隊列
                    nativeWake(mPtr);
                }
            }
            return true;
    }
}

消息出隊列

Looper調用MessageQueue的next()方法去除消息

public final class MessageQueue {
    Message next() {
        // 如果消息循環已經退出並被處理，請返回此處。
        // 如果應用程序嘗試退出後不支持的循環程序，則會發生這種情況
        final long ptr = mPtr;
        //當消息循環已經退出，則直接返回
        if (ptr == 0) {
            return null;
        }

        int pendingIdleHandlerCount = -1; //只有第一次賦值爲-1
        //初始化下一次poll喚醒延時
        int nextPollTimeoutMillis = 0;
        for (;;) {
            //只要延時不爲0，刷新待定命令
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            //阻塞操作，當等待nextPollTimeoutMillis時長，或者消息隊列被喚醒，都會返回，
            //***這就是主線程爲什麼一直不阻塞主線程
            //實際調用的是c++層ALooer::pollOnce方法，通過 mCondition.wait來等待
            //mCondition.waitRelative(mLock, waitUntilNs - nowNs);
            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // 嘗試檢索下一條消息。 如果找到則返回。
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // 查詢MessageQueue中的下一條異步消息
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // 設置下一次輪詢消息的超時時間
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // 獲取一條消息，並返回 zz
                        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 {
                    //沒有消息
                    nextPollTimeoutMillis = -1;
                }

                // 現在已處理所有掛起的消息，請處理退出消息。
                if (mQuitting) {
                    dispose();
                    return null;
                }

                // 如果是第一次空閒，則獲取要運行的惰輪數量。
                //空閒句柄僅在隊列爲空或將來要處理隊列中的第一條消息（可能是屏障）時才運行。
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    // 沒有空閒的處理程序可以運行。 循環並等待更多。
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

            // 只有第一次循環時，會運行idle handlers，執行完成後，重置pendingIdleHandlerCount爲0.
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // 釋放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);
                    }
                }
            }

            // 將空閒處理程序計數重置爲0，這樣我們就不再運行它們。
            pendingIdleHandlerCount = 0;

            //調用空閒處理程序時，可能已經傳遞了一條新消息，因此請返回並再次查找未決消息，而無需等待。
            nextPollTimeoutMillis = 0;
        }
    }
}

消息移除

通過Handler的MessageQueue.removeMessages移除消息

public final class MessageQueue {

    void removeMessages(Handler h, int what, Object object) {
        //handler不能爲空
        if (h == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // 當是當前消息時，移除頭結點
            while (p != null && p.target == h && p.what == what
                   && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

            // 移除頭結點之後的所有消息
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.what == what
                        && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }
}

退出消息循環

public final class MessageQueue {

    void quit(boolean safe) {
        //主線程不能退出，否則拋出錯誤
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            //已經調用退出攔截
            if (mQuitting) {
                return;
            }
            //改變退出標識
            mQuitting = true;
            //是否安全退出
            if (safe) {
                //只移除大於當前時間的結點
                removeAllFutureMessagesLocked();
            } else {
                //直接遍歷所有Message
                removeAllMessagesLocked();
            }

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


    //直接遍歷移除所有message結點
    private void removeAllMessagesLocked() {
        Message p = mMessages;
        while (p != null) {
            Message n = p.next;
            p.recycleUnchecked();
            p = n;
        }
        mMessages = null;
    }

    //移除大於當前時間結點
    private void removeAllFutureMessagesLocked() {
        final long now = SystemClock.uptimeMillis();
        Message p = mMessages;
        if (p != null) {
            if (p.when > now) {
                removeAllMessagesLocked();
            } else {
                Message n;
                for (;;) {
                    n = p.next;
                    if (n == null) {
                        return;
                    }
                    if (n.when > now) {
                        break;
                    }
                    p = n;
                }
                p.next = null;
                do {
                    p = n;
                    n = p.next;
                    p.recycleUnchecked();
                } while (n != null);
            }
        }
    }
}

Message

Message設計

複用

public final class Message implements Parcelable {

    /** 構造函數 (但是最好調用{@link #obtain() Message.obtain()}).
    */
    public Message() {
    }

    public static Message obtain() {
        //首先Message池裏面取出消息，如果sPool沒有消息，接直接new
        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();
    }
}

Message設計了一個最大容量爲50的Message複用池，各個線程均從當前Message池中取出消息重複使用，防止過多的new操作，耗費性能

總結

Android的所有線程的消息處理，都是通過Handler來發送和處理，然後通過Looper循環從MessageQueue中取出消息，交由Handler處理