作為一個Android開發(fā)者禀梳，肯定是用過Handler的滩租。
而Handler最常見的使用場景迎罗，就是在子線程里進(jìn)行更新UI的操作了钻注。
我最開始以為Handler就是幫助我們將線程切換到主線程(也就是UI線程)，可是后來我發(fā)現(xiàn)Handler是可以切換到任意線程的统锤，而切換到主線程只是Handler最常用的功能而已毛俏。

我們先來看下最常見的Handler寫法：

  Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            tv.setText("World!");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);

        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(3000);
                handler.sendEmptyMessage(0);
            }
        }).start();
    }

這段代碼我們開啟了一個線程，然后睡眠了三秒饲窿，睡眠之后我們更新了TextView煌寇。如果我們直接在線程里寫更新UI的代碼，是會報錯的逾雄，因為Android的UI操作是線程不安全的阀溶，于是我們就需要Handler將我們的操作切換到主線程中去。

那么我們今天分析源碼的目的嘲驾，就是看看Handler機(jī)制的流程是什么淌哟，里面做了些什么。

我們按照順序來辽故，上面的代碼中徒仓，會執(zhí)行到handler.sendEmptyMessage(0)這句話，我們跟進(jìn)去看看：

   public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }

它直接返回了sendEmptyMessageDelayed方法誊垢，我們看下sendEmptyMessageDelayed這個方法：

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

它返回了sendMessageDelayed方法掉弛，在看這個方法前症见，我們看下Message.obtain()是啥，為啥是obtain()而不是直接New一個：

public static Message obtain() {
        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();
    }

我們可以發(fā)現(xiàn)Message是一個鏈表殃饿，然后Android內(nèi)部維護(hù)了一個消息池谋作，可以減少我們直接New Message的情況，既然Android已經(jīng)提供了消息池乎芳，那我們自己New浪費空間遵蚜。
這里的邏輯我解釋一下，Message是一個鏈表奈惑，sPool也是個鏈表吭净，sPool里面套著一串Message，然后先把sPool賦值給Message,再把Message的next置為null肴甸，把flag清零寂殉，就相當(dāng)于從sPool中取出頭部的Message來賦值。

好了我們繼續(xù)看sendMessageDelayed方法：

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

這里修正了一下delayMillis小于零的情況原在，然后返回了sendMessageAtTime友扰，注意這里sendMessageAtTime里的參數(shù)，將本來延時時間庶柿，改成了一個準(zhǔn)確的事件村怪。
我們繼續(xù)跟進(jìn)：

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

這里我們先看到mQueue被賦值給了queue，那么mQueue肯定不是空的啊澳泵，我們看看mQueue是什么時候被賦的值：

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

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

我們發(fā)現(xiàn)mQueue是在Handler(Callback callback, boolean async)這個構(gòu)造方法里被賦的值实愚，并且我還發(fā)現(xiàn)new Handler()這個構(gòu)造方法，其實也是調(diào)用了this(null, false)兔辅，也就是Handler(Callback callback, boolean async)這個構(gòu)造方法，好了击喂，那我們繼續(xù)看维苔。

我們發(fā)現(xiàn)mQueue被賦了mLooper.mQueue，而mLooper是Looper.myLooper()返回的懂昂。

那我們看看myLooper()里做了啥：

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

我們看到這個方法就是返回了sThreadLocal.get()介时，那ThreadLocal是啥，其實它就是一個存東西的凌彬，而且是根據(jù)線程來存東西沸柔。上網(wǎng)找了找它的描述：ThreadLocal為每個使用該變量的線程提供獨立的變量副本，所以每一個線程都可以獨立地改變自己的副本铲敛，而不會影響其它線程所對應(yīng)的副本褐澎。
也就是說，每一個線程中的mLooper是獨立的伐蒋，這就有趣了工三，我們可以隱約的察覺到什么迁酸。我們可以猜測一下，既然每個線程中的mLooper是獨立的俭正，那我們線程的溝通切換啥的奸鬓，就根據(jù)mLooper來進(jìn)行就好了。

我們發(fā)現(xiàn)下面有行代碼：

if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }

它判斷了一下mLooper是否為空掸读，也就是是否被初始化串远，如果沒有的話，就會拋出個異常儿惫。說不能創(chuàng)建Handler抑淫，因為你沒有調(diào)用Looper.prepare()。那么問題來了姥闪，我們最開始那個例子始苇，沒有調(diào)用這個函數(shù)不也創(chuàng)建成功了嗎？
這是因為程序在啟動的時候筐喳，已經(jīng)調(diào)用了Looper.prepare()這個方法催式，我們看下ActivityThread的main方法：

public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

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

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

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

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

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

發(fā)現(xiàn)有一個Looper. prepareMainLooper()，我們跟進(jìn)去看看：

public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

我們發(fā)現(xiàn)就是在這里調(diào)用了prepare方法避归。

好了荣月，那我們現(xiàn)在來看看prepare方法干了啥：

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

我們發(fā)現(xiàn)它顯示判斷了一下當(dāng)前線程是否已經(jīng)存在了Looper，有的話就拋出異常梳毙，說一個線程只能有一個Looper哺窄。如果沒有的話就new一個Looper然后放進(jìn)這個線程里。
我們繼續(xù)看看new Looper(quitAllowed)里面是啥:

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

我們發(fā)現(xiàn)账锹，在這個構(gòu)造方法里萌业，新建了一個MessageQueue賦值給了mQueue，并且把當(dāng)前的線程給了mThread奸柬。
至于MessageQueue是啥生年，我在這里貼上源碼里的注釋，并簡單翻譯下：

Low-level class holding the list of messages to be dispatched by a
 * {@link Looper}.  Messages are not added directly to a MessageQueue,
 * but rather through {@link Handler} objects associated with the Looper.
 * 
 * <p>You can retrieve the MessageQueue for the current thread with
 * {@link Looper#myQueue() Looper.myQueue()}.

上面大致的意思就是MessageQueue持有一串的messages廓奕，然后等著Looper來分發(fā)它們抱婉。并且messages不會被直接的加進(jìn)MessageQueue里，而是需要Handler與Looper配合來完成操作桌粉。

好了蒸绩，讀到這里，我們繼續(xù)回到sendMessageAtTime方法里铃肯，大家是不是已經(jīng)忘了呢患亿，是不是看的暈了呢，哈哈哈哈反正我很爽缘薛，你來打我呀窍育！
我們繼續(xù)讀發(fā)現(xiàn)sendMessageAtTime方法返回了enqueueMessage并且把queue卡睦，msg，uptimeMillis傳了進(jìn)去漱抓。我們繼續(xù)跟進(jìn)：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

我們發(fā)現(xiàn)第一句： msg.target = this表锻，this指的是當(dāng)前的Handler，那么msg.target是啥呢乞娄？
其實它就是一個Handler瞬逊，也就是說在這里，把我們的Handler與Message關(guān)聯(lián)起來了仪或！
之后就是判斷下是否要異步操作确镊，然后返回MessageQueue的enqueueMessage方法：

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

我們發(fā)現(xiàn)這就是一個鏈表的插入操作，也就是把Message放進(jìn)MessageQueue的過程范删，這里插入的操作邏輯大概是這樣的：
判斷表頭是不是空的蕾域，是的話就直接插進(jìn)頭里；判斷要執(zhí)行的時間是不是最小的到旦，是的話也把它插進(jìn)頭里旨巷；如果上面兩個條件都不滿足，那么就遍歷一下鏈表添忘，找個合適的位置插入采呐。

好了，這個時候搁骑，我們的Message就放進(jìn)MessageQueue里了斧吐，那么我們就這樣結(jié)束了嗎？當(dāng)然沒有仲器！有進(jìn)去就有出來懊郝省！我們怎么才能把Message從MessageQueue里面取出來呢娄周？
還記得我們之前講的MessageQueue的描述嗎涕侈，說它等著被Looper來分發(fā)，既然如此煤辨，我們看看Looper的源碼：

/**
     * 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.isTagEnabled(traceTag)) {
                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();
        }
    }

茫茫代碼中，一眼就找到了這段代碼木张，哈哈哈哈众辨，loop方法就是用來分發(fā)MessageQueue里的Message的，并且我們也看到了舷礼，它是一個死循環(huán)鹃彻，在使用完后記得用quit()來退出。順帶一提妻献，Looper.loop()也是在ActivityThread的main()方法里調(diào)用開啟的蛛株。
代碼最開始就是判斷一下Looper有沒有被創(chuàng)建团赁，有的話就開始了一個死循環(huán)來分發(fā)Message。我們看死循環(huán)里的代碼谨履，首先Message msg = queue.next()會去取queue里的Message欢摄，若是空的，那么就會阻塞住笋粟，直到有了Message進(jìn)來怀挠，就會開始分發(fā)。
然后代碼一路下來害捕，我們看到一句msg.target.dispatchMessage(msg)绿淋，從名字上也看的出來這是分發(fā)的方法了，那么target是什么呢尝盼，我們之前已經(jīng)分析過了吞滞，就是我們的Handler呀！
我們看下dispatchMessage方法是啥樣的：

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

這里的邏輯是這樣的盾沫，也判斷msg的callback是不是空的裁赠，如果不是空的，就調(diào)用handleCallback方法：

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

也就是調(diào)用的msg的callback
然后如果msg.callback是空的疮跑，那么先判斷mCallback是不是空的组贺，如果不是空的，就調(diào)用的mCallback.handleMessage(msg)方法祖娘。
最后實在不行失尖，再去調(diào)用自己的handleMessage(msg)方法：

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

這個方法是個空方法，需要我們自己去實現(xiàn)渐苏，這個方法也就是我們最開始例子里面的那個handleMessage方法掀潮。
好了，經(jīng)過種種的調(diào)用邏輯琼富，終于從最終的handler.sendEmptyMessage(0)方法仪吧，來到了handleMessage方法，結(jié)束了這個旅程鞠眉。

總結(jié)一下：

首先Looper我們需要用prepare()創(chuàng)建薯鼠，并用loop()開啟，創(chuàng)建時Looper會和當(dāng)前的線程關(guān)聯(lián)械蹋，我們最開始的例子不用這樣是因為程序執(zhí)行時在主線程已經(jīng)創(chuàng)建并開啟過了出皇。
然后我們創(chuàng)建一個Message，然后通過Handler的各種sendMessage方法發(fā)送出去(這里的各種send方法最后都會到同一個方法里哗戈，大家可以自己跟)郊艘，然后進(jìn)行MessageQueue的入隊操作，并且這個時候，將Handler與Message關(guān)聯(lián)起來了纱注。
最后就是勤勞的Looper不斷的取消息畏浆，沒消息就等著，有消息就取出來交給Handler去分發(fā)處理狞贱。

結(jié)束：

這篇文章寫的順序就是我看源碼的順序刻获，大家看的時候可以一邊開著源碼一邊看。我覺得不是很難(可能我太垃圾)斥滤，主要是理一個思路将鸵。
水平不高，大家可能看的云里霧里的佑颇，見諒顶掉。
不知道為什么，這篇文章寫的我很開心挑胸，看源碼也看的很開心痒筒，可能我女朋友太可愛了吧。

如果有問題茬贵，請在評論區(qū)留言簿透，才疏學(xué)淺，歡迎大家批評指正解藻。