Handler Looper Message Thread

首先要闡述幾者之間的關係。
Thread 可以擁有多個handler物件；
Thread 只能擁有一個Looper 和一個MessageQueue。

Looper 只能屬於一個Thread， 並且只能和MessageQueue 一一對應。 looper的在幾者中的作用是什麼呢！
Looper的作用就是起到 發動機的原理，當然它不是讓車跑起來，而是讓MessageQueue裡的message被執行。
那麼 Message被誰執行呢？ 後文即會提到。

MessageQueue 也僅是和一個looper繫結，在出生的時候即決定了這件事，後面在程式碼中會解釋為什麼！
MessageQueue裡面存放就是 Message。

Looper

首先需要關注的是該方法。

public static void prepare() {
    prepare(true);
}

引數為是否允許退出，答案是肯定的 true; 只有一種情況即主執行緒呼叫prepare時傳遞false,因為主執行緒不允許退出。
該方法即為 預熱發動機的入口。讓 Looper這臺機器進行啟動之前的準備工作。

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

分析一下 是如何判斷已經prepare的呢？
sThreadLocal.get() != null
那就需要看一下set是什麼東東。就是準備的是什麼呢？

/**
 * Sets the current thread's copy of this thread-local variable
 * to the specified value.  Most subclasses will have no need to
 * override this method, relying solely on
 
 the {@link #initialValue}
 * method to set the values of thread-locals.
 *
 * @param value the value to be stored in the current thread's copy of
 *        this thread-local.
 */
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

這個value就是上文提到的 new Looper(quitAllowed)
createMap建立的是一個ThreadLocalMap。
每一個執行緒僅有一個ThreadLocalMap， 在該map中儲存內容為該執行緒本地變數的副本。ThreadLocalMap使用及注意事項以後單獨開講。

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

當第一次sThreadLocal.get()時，會返回setInitialValue=null;

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

當一個執行緒只能有一個Looper之後也就意味著只能有一個MessageQueue.class

Looper.loop即為啟動發動機的入口，啟動之後開始進行訊息輪詢，並且註釋說明一定要呼叫quit()退出輪詢。
Looper一直把MesageQueue所有的message執行完。
每執行完一個後即通過next拿到下一個message.

public static void loop() {
---
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 {
            msg.target.dispatchMessage(msg); //msg.target即為執行message工具。
        } 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();
    }
}

MessageQueue
MessageQueue和Looper之間有個緊密的聯絡就是通過 MessageQueue.next()方法。以next方法為切入點介紹MessageQueue.class

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

        //natvie層進行阻塞,後文在Looper.c中介紹
        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.
                    //如果當前的msg沒有準備好，那麼就下次輪詢進入到等待。
                    //計算等待時間
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    //標記當次輪詢不會被wait,不需要被喚醒
                    mBlocked = false;
                    //當在連結串列佇列中找到可執行msg,把當前message調出，並修復原連結
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    //標記當前msg被使用狀態
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            //如果looper呼叫了quit, messagequeue也進行退出操作。
            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.
            // 引入了另外一個messagequeue的功能, idle handles的處理，
            // 當佇列為空的時候或沒有任務可執行的時候，執行idle handles內容。
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                // 既沒有idle handlers 和message可以處理那麼就需要阻塞,入隊時候就需要喚醒。
                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 {
                //執行idler中的回撥，並且有返回值，true意味著想要保持這個idle下次繼續執行，
                //false則會從佇列中移除
                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;
    }
}

下面繼續介紹enqueueMessage，入隊操作由Handler.class執行。後文提到其中幾種入隊操作。

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) {
        //如果looper已經條用quit，那麼就放棄入隊。
        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.
            // 如果messagequeue中沒有message或者需要立即執行或者插入message時間優於對頭
            // message所需要執行時間，那麼就把msg插入到對頭。
            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.
            //通常情況下將目標message插入到隊裡中間時，是不需要喚醒佇列的，
            //除非有一個"同步分隔欄"在對頭或者目標message是最早需要執行的非同步message。
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    //找到最後一個位置，或者時間排序上晚於目標message的位置
                    break;
                }
                //當需要喚醒，但是 要插入目標message的前面所有位置的message
                //只要有非同步訊息的話既不需要喚醒。
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            // 將目標message插入到理想位置，修復整個連結
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            //此處為喚醒 Looper
            nativeWake(mPtr);
        }
    }
    return true;
}

上面介紹了MessageQueue的兩個主要方法next()和enqueueMessage()，其中涉及到了兩個native層的本地方法分別為：
nativePollOnce(ptr, nextPollTimeoutMillis);
nativeWake(mPtr);
那麼下面介紹一下這兩個方法。
方法在/frameworks/base/core/jni/android_os_MessageQueue.cpp中進行了定義。

static JNINativeMethod gMessageQueueMethods[] = {
    /* name, signature, funcPtr */
    { "nativeInit", "()V", (void*)android_os_MessageQueue_nativeInit },
    { "nativeDestroy", "()V", (void*)android_os_MessageQueue_nativeDestroy },
    { "nativePollOnce", "(II)V", (void*)android_os_MessageQueue_nativePollOnce },
    { "nativeWake", "(I)V", (void*)android_os_MessageQueue_nativeWake }
};

static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jint ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(timeoutMillis);
}

最終呼叫到Looper::pollOnce====>Looper::pollInner

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData);
int Looper::pollInner(int timeoutMillis);

int Looper::pollInner(int timeoutMillis) {
    ---
#ifdef LOOPER_USES_EPOLL
    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    //通過Epoll進行阻塞
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
#else
    // Wait for wakeAndLock() waiters to run then set mPolling to true.
    mLock.lock();
    while (mWaiters != 0) {
        mResume.wait(mLock);
    }
    mPolling = true;
    mLock.unlock();

    size_t requestedCount = mRequestedFds.size();
    int eventCount = poll(mRequestedFds.editArray(), requestedCount, timeoutMillis);
#endif
    ---
}

其中最終運用epoll進行控制（epoll不再本文討論感興趣讀者可自行查詢！
）。下面引入《深入理解Android：卷II》對pollOnce解釋：

其中四個引數：
timeoutMillis引數為超時等待時間。如果值為–1，則表示無限等待，直到有事件發生為止。如果值為0，則無須等待立即返回。
outFd用來儲存發生事件的那個檔案描述符。
outEvents用來儲存在該檔案描述符上發生了哪些事件，目前支援可讀、可寫、錯誤和中斷4個事件。這4個事件其實是從epoll事件轉化而來的。後面我們會介紹大名鼎鼎的epoll。
outData用於儲存上下文資料，這個上下文資料是由使用者在新增監聽控制代碼時傳遞的，它的作用和pthread_create函式最後一個引數param一樣，用來傳遞使用者自定義的資料。
另外，pollOnce函式的返回值也具有特殊的意義，具體如下：
當返回值為ALOOPER_POLL_WAKE時，表示這次返回是由wake函式觸發的，也就是管道寫端的那次寫事件觸發的。
返回值為ALOOPER_POLL_TIMEOUT表示等待超時。
返回值為ALOOPER_POLL_ERROR表示等待過程中發生錯誤。
返回值為ALOOPER_POLL_CALLBACK表示某個被監聽的控制代碼因某種原因被觸發。這時，outFd引數用於儲存發生事件的檔案控制代碼，outEvents用於儲存所發生的事件。

MessageQueue還有其他公開方法：

用來新增IdleHandler，當沒有message需要立即處理時就會處理IdleHandler。

void addIdleHandler(@NonNull IdleHandler handler);
void removeIdleHandler(@NonNull IdleHandler handler);

用來新增需要監聽的檔案描述符fd

void addOnFileDescriptorEventListener(@NonNull FileDescriptor fd,
            @OnFileDescriptorEventListener.Events int events,
            @NonNull OnFileDescriptorEventListener listener);
void removeOnFileDescriptorEventListener(@NonNull FileDescriptor fd);

Message.class
主要是handler要處理的信使，主要功能攜帶引數。下面主要介紹handler引數。

/**
 * User-defined message code so that the recipient can identify 
 * what this message is about. Each {@link Handler} has its own name-space
 * for message codes, so you do not need to worry about yours conflicting
 * with other handlers.
 */
public int what;
//定義在handler中要執行的事件

/**
 * arg1 and arg2 are lower-cost alternatives to using
 * {@link #setData(Bundle) setData()} if you only need to store a
 * few integer values.
 */
public int arg1; 
//如果要儲存簡單的引數，使用arg1和arg2就可以

/**
 * arg1 and arg2 are lower-cost alternatives to using
 * {@link #setData(Bundle) setData()} if you only need to store a
 * few integer values.
 */
public int arg2;

/**
 * An arbitrary object to send to the recipient.  When using
 * {@link Messenger} to send the message across processes this can only
 * be non-null if it contains a Parcelable of a framework class (not one
 * implemented by the application).   For other data transfer use
 * {@link #setData}.
 * 
 * <p>Note that Parcelable objects here are not supported prior to
 * the {@link android.os.Build.VERSION_CODES#FROYO} release.
 */
public Object obj;
//可儲存任意型別引數

/**
 * Optional Messenger where replies to this message can be sent.  The
 * semantics of exactly how this is used are up to the sender and
 * receiver.
 */
public Messenger replyTo;
//可實現跨程序通訊，後面會獨立章節進行講解。

/**
 * Optional field indicating the uid that sent the message.  This is
 * only valid for messages posted by a {@link Messenger}; otherwise,
 * it will be -1.
 */
public int sendingUid = -1;
//與Messenger 配合使用

/*package*/ int flags;
//0x00 非使用， 0x01被使用：當入隊和被回收的時候會設定為1
//0x10 表示為非同步

/*package*/ long when;
//延遲執行時間

/*package*/ Bundle data;
//儲存一些複雜資料

/*package*/ Handler target;
//執行該message的handler

/*package*/ Runnable callback;
//hanlder執行該message時，如果有callback即執行該callback

// sometimes we store linked lists of these things
/*package*/ Message next;
//儲存連結串列

主要解析一下該函式

/**
* Return a new Message instance from the global pool. Allows us to
 * avoid allocating new objects in many cases.
 */
public static Message obtain() {
    //sPoolSync 同步鎖
    synchronized (sPoolSync) {
        //sPool指向連結串列的頭
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            //將sPool取出，並斷鏈
            return m;
        }
    }
    //如果鏈中沒有元素，重新分配
    return new Message();
}

/**
 * Recycles a Message that may be in-use.
 * Used internally by the MessageQueue and Looper when disposing of queued Messages.
 */
void recycleUnchecked() {
    // Mark the message as in use while it remains in the recycled object pool.
    // Clear out all other details.
    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++;
            //將該message插入頭部
        }
    }
}

Handler
先比較前幾個Class， Handler比較簡單，成員只有以下幾個：

final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;

先看幾個比較重要的構造方法：

//常用的為無參構造形式
public Handler() {
    this(null, false);
}

//這是無參構造方法呼叫的真正構造方法， 
public Handler(Callback callback, boolean async) {
    //FIND_POTENTIAL_LEAKS
    //將此標誌設定為true以檢測擴充套件的Handler類, 擴充套件的handler類如果不是靜態的匿名,本地或成員類, 
    //則會產生洩漏。我們常見構造時的警告說明!至於消除警告方法一般是設定成靜態或弱引用。
    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());
        }
    }

    //mLooper是來自於sThreadLocal中ThreadLocalMap中 通過呼叫執行緒ID儲存的looper,唯一
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    //mqueue來自looper， 也唯一
    mQueue = mLooper.mQueue;
    mCallback = callback;
    //標示該handler傳送的資料是否為非同步資料。
    mAsynchronous = async;
}

通過分析構造方法可驗證前文提到的
handler 僅對應一個looper MessageQueue,，翻過來不成立，也就是說會有多個handler繫結在同一個Looper中。

通過呼叫post(Runnable r)； postDelayed(Runnable r, long delayMillis);sendMessage(Message msg)；等方法傳送的時間，最終呼叫下面的方法。

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;
    //如果為非同步，則對每一個message進行設定。
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    //呼叫enqueueMessage 進行入隊Message
    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;
    }
    //與enqueueMessage差別為uptimeMillis=0. 在messagequeue中當遇到when=0時，
    //會將該message放在對頭進行處理
    return enqueueMessage(queue, msg, 0);
}

在需要注意下，這個remove方法，當傳入null時可將MessageQueue中的所有資料remove掉。

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

回過頭來說一下上面的 同步分隔欄，

在Api 23 之， 通過MessageQueue 進行呼叫

/**
 * Posts a synchronization barrier to the Looper's message queue.
 *
 * Message processing occurs as usual until the message queue encounters the
 * synchronization barrier that has been posted.  When the barrier is encountered,
 * later synchronous messages in the queue are stalled (prevented from being executed)
 * until the barrier is released by calling {@link #removeSyncBarrier} and specifying
 * the token that identifies the synchronization barrier.
 *
 * This method is used to immediately postpone execution of all subsequently posted
 * synchronous messages until a condition is met that releases the barrier.
 * Asynchronous messages (see {@link Message#isAsynchronous} are exempt from the barrier
 * and continue to be processed as usual.
 *
 * This call must be always matched by a call to {@link #removeSyncBarrier} with
 * the same token to ensure that the message queue resumes normal operation.
 * Otherwise the application will probably hang!
 *
 * @return A token that uniquely identifies the barrier.  This token must be
 * passed to {@link #removeSyncBarrier} to release the barrier.
 *
 * @hide
 */
 // 該方法為hide, 正常寫程式碼是呼叫不到的。
public int postSyncBarrier() {
    return postSyncBarrier(SystemClock.uptimeMillis());
}

// The next barrier token.
// Barriers are indicated by messages with a null target whose arg1 field carries the token.
// 同步分隔欄訊息沒有target, 並且arg1用來記錄token
private int mNextBarrierToken;

private int postSyncBarrier(long when) {
    // Enqueue a new sync barrier token.
    // We don't need to wake the queue because the purpose of a barrier is to stall it.
    synchronized (this) {
        final int token = mNextBarrierToken++;
        final Message msg = Message.obtain();
        msg.markInUse();
        msg.when = when;
        msg.arg1 = token;

        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
        }
        if (prev != null) { // invariant: p == prev.next
            msg.next = p;
            prev.next = msg;
        } else {
            msg.next = p;
            mMessages = msg;
        }
        return token;
    }
}

這個同步分隔message有什麼作用呢？
對開發者沒有明顯的提供，那麼就是在系統及別使用。在ViewRootImpl.java中進行了使用。

void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        if (!mUnbufferedInputDispatch) {
            scheduleConsumeBatchedInput();
        }
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

為了讓View能夠有快速的佈局和繪製，ViewRootImpl在開始measure和layout ViewTree時，會向主執行緒的Handler新增同步分隔message,這樣後續的訊息佇列中的同步的訊息將不會被執行，以免會影響到UI繪製，但是隻有非同步訊息才能被執行。如果想要使用postSyncBarrier() 那麼就需要使用反射進行使用。

總結
Looper、MessageQueue 和 Thread 一一對應。
Handler 需要繫結到一個Looper中， 一個Looper可以有多個Handler。

這是第一文章，以後會多多寫的。歡迎各位指正問題！謝謝。
[email protected]