很早之前就Handler的分析，不過(guò)感覺(jué)有點(diǎn)亂亂的，所以趁著有時(shí)間就將其改了改。
　　
　　Handler是我們android開(kāi)發(fā)中經(jīng)常使用的一個(gè)類，一般我們?cè)谧泳€程中做了耗時(shí)操作后使用handler來(lái)發(fā)送一個(gè)消息到主線程中去刷新UI，因?yàn)锳ndroid要求UI的刷新必須在主線程中來(lái)執(zhí)行，所以使用handler來(lái)實(shí)現(xiàn)我們的目的是非常方便的。我們一般會(huì)使用handler來(lái)做刷新UI的操作，但是handler提供的功能可不僅僅只是在UI線程中來(lái)處理，它也可以子線程中處理消息。說(shuō)起Handler一般都會(huì)和Looper、Message、MessageQueue聯(lián)系起來(lái)，Looper是一個(gè)循環(huán)器不停的從MessageQueue中Message息交給Handler來(lái)處理。
　　我們一般使用的時(shí)候就是直接new Handler()然后覆寫(xiě)handleMessage()方法就可以在主線程中處理任務(wù)了。為什么沒(méi)有看到Looper和MessageQueue的身影了，如果我們?cè)谧泳€程中去new Handler()會(huì)發(fā)生什么情況呢？
　　下面我們從源碼的角度來(lái)看看handler是怎么工作的。

我們知道，Android應(yīng)用啟動(dòng)的入口在ActivityThread這個(gè)類，里面就能看到看到我們?cè)趯W(xué)習(xí)java的時(shí)候main函數(shù)的身影，在main方法中，會(huì)自動(dòng)在線程中初始化Looper，所以我們?cè)谥骶€程中去new Handler()的時(shí)候是不需要關(guān)心這個(gè)的，因?yàn)橐呀?jīng)幫我們做好了。我們先來(lái)看看main方法中到底做了什么：

public static void main(String[] args) {
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
    ...//不相關(guān)的內(nèi)容
    //初始化Looper
    Looper.prepareMainLooper();
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    ...
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    //開(kāi)啟循環(huán)，此處looper來(lái)陷入一個(gè)死循環(huán)中不停的取出消息并處理，一旦looper停止，那么我們的應(yīng)用也就結(jié)束
    Looper.loop();
    //looper停止的話就會(huì)走到這里拋出異常
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

在一進(jìn)入main方法中就調(diào)用了Looper.prepareMainLooper()這個(gè)方法，然后就調(diào)用了Looper.loop()方法，我們接著跳進(jìn)去看看里面做了什么

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static void prepareMainLooper() {
    //創(chuàng)建一個(gè)主線程使用的looper
    prepare(false);
    synchronized (Looper.class) {
        //如果已經(jīng)存在了main looper拋出異常
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        //保存主線程中的looper
        sMainLooper = myLooper();
    }
}

private static void prepare(boolean quitAllowed) {
    //如果重復(fù)創(chuàng)建拋出異常
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    //使用threadLocal來(lái)保存looper對(duì)象，該looper對(duì)象只能被主線程訪問(wèn)
    sThreadLocal.set(new Looper(quitAllowed));
}

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

看到Looper里面也沒(méi)有神秘的東西，還是挺簡(jiǎn)單的，Looper里面使用了一個(gè)ThreadLocal，它能夠提供線程獨(dú)立的數(shù)據(jù)，線程之間使用ThreadLocal保存的數(shù)據(jù)互不干擾，對(duì)于不清楚ThreadLocal的可以參考ThreadLocal源碼分析
可以看到prepareMainLooper只是創(chuàng)建了一個(gè)looper對(duì)象跟主線程關(guān)聯(lián)起來(lái)。

public static void loop() {
    //當(dāng)前線程為主線程，所以取到的looper就是一個(gè)主線程中的looper
    final Looper me = myLooper();
    if (me == null) {
        //這里告訴我們，如果在子線程中使用looper的話，不調(diào)用Looper.prepare()是會(huì)gg的，看到這個(gè)異常是不是很熟悉啊
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    //在Looper的構(gòu)造方法中就會(huì)初始化一個(gè)MeesageQueue對(duì)象，就一行代碼，這里就不貼了
    final MessageQueue queue = me.mQueue;
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    for (;;) {
        //如果MeesageQueue沒(méi)有消息，這里會(huì)阻塞等待知道有消息過(guò)來(lái)
        Message msg = queue.next(); // might block
        if (msg == null) {
            //如果這里為null，說(shuō)明MessageQueue停止運(yùn)行了，也就不能處理主線程的邏輯了，程序就退出了
            return;
        }
        final Printer logging = me.mLogging;
 
        final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        final long end;
        try {
            //從msg中取出Handler對(duì)象，然后調(diào)用handler.dispatchMessage()方法
            //在handler發(fā)送消息的時(shí)候，會(huì)將自己也封裝在message中，所以這里我們才能處理消息
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        ...
        msg.recycleUnchecked();
    }
}

在looper中我們看到了一個(gè)神奇的東西for (;;)，一個(gè)死循環(huán)，在該死循環(huán)中不停的取出message消息，如果沒(méi)有消息MessageQueue就阻塞。有些小伙伴可能會(huì)驚訝，這里阻塞了那主線程的其他地方怎么執(zhí)行??？可以告訴你，在應(yīng)用實(shí)際運(yùn)行中，處理ActivityThread.main()中在Looper.loop()之前，其他主線程的代碼都是在這個(gè)死循環(huán)中執(zhí)行的，一樣這個(gè)循環(huán)退出，應(yīng)用也就結(jié)束了，我們也看到Looper.loop()是在main()方法的最后才調(diào)用的就是這么一個(gè)道理。
在loop()方法中做的事情很簡(jiǎn)單，就是不停的取消息然后交給handler來(lái)處理，如果沒(méi)有消息了就阻塞等待直到有消息為止。
Looper的初始化就這么簡(jiǎn)單。我們接下來(lái)看看Handler中有什么，經(jīng)常用它們也不能不知道它里面到底有啥。

我們先從sendMessage()這里說(shuō)起，它是我們發(fā)消息的出發(fā)點(diǎn)。

//sendEmptyMessage
public final boolean sendEmptyMessage(int what)
{
    return sendEmptyMessageDelayed(what, 0);
}
//sendEmptyMessageDelayed
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}
//sendEmptyMessageAtTime
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageAtTime(msg, uptimeMillis);
}
//sendMessage
public final boolean sendMessage(Message msg){
    return sendMessageDelayed(msg, 0);
}
//sendMessageDelayed
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
 //sendMessageAtTime
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);
}
//sendMessageAtFrontOfQueue
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里面封裝了好幾種發(fā)送消息的方法，但是最終它們調(diào)用enqueueMessage()，所以我們來(lái)看看它里面到底是怎么實(shí)現(xiàn)的

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    //將handler本身賦值給target
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    //將消息添加到隊(duì)列
    return queue.enqueueMessage(msg, uptimeMillis);
}

這里先將handler本身賦值給msg.target，然后調(diào)用queue.enqueueMessage將消息添加到消息隊(duì)列里面。這也就是為什么在looper的死循環(huán)里面從消息中取出handler的原因，要是這里不設(shè)置我們的handler，消息是不能在我們自己的handler中處理的。其中queue是handler在構(gòu)造方法中初始化的時(shí)候從主線程的looper中拿到的

public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

到這里，是不是感覺(jué)整個(gè)Handler的流程一下就頓悟了很多。
我們接著上面的說(shuō)，在looper中最終會(huì)調(diào)用我們的handler的dispatchMessage()方法，來(lái)看看：

public void dispatchMessage(Message msg) {
    //如果有msg中有callback，那么在callback中處理消息
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            //如果我們?cè)趧?chuàng)建handler的時(shí)候設(shè)置了callback，那么也在這個(gè)callback中處理消息
            //這個(gè)callback和msg.callback不是一個(gè)東西，不要搞混了
            if (mCallback.handleMessage(msg)) {
                //如果消息處理成功就退出
                return;
            }
        }
        //如果以上都沒(méi)有處理或者是mCallback返回false，那么調(diào)用handleMessage()來(lái)處理
        handleMessage(msg);
    }
}

看到了啥，handleMessage()竟然是在這里被調(diào)用的，一下子又哦哦哦了。
不過(guò)發(fā)現(xiàn)handleMessage()是最好才被處理的。那前面幾個(gè)callback是什么呢？
先說(shuō)msg.callback()，除了handler提供了幾個(gè)sendxxxMessage()方法外，還提供了幾個(gè)post方法來(lái)發(fā)送消息。

public final boolean post(Runnable r){
   return  sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis){
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){
    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
public final boolean postDelayed(Runnable r, long delayMillis){
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}
public final boolean postAtFrontOfQueue(Runnable r){
    return sendMessageAtFrontOfQueue(getPostMessage(r));
}

竟然還是調(diào)用了我們的send方法來(lái)發(fā)送消息，簡(jiǎn)直了就是。不過(guò)這里的message好像有點(diǎn)不一樣，看看這里做了什么。

private static Message getPostMessage(Runnable r, Object token) {
    Message m = Message.obtain();
    m.obj = token;
    m.callback = r;
    return m;
}

看到了啥，msg.callback就是我們?cè)趐ost中傳遞的runnable對(duì)象，這里還有一個(gè)重載方法getPostMessage(Runnable r)，它們處理token不一樣，其他都一樣就不說(shuō)了。我們知道了msg.callback就是一個(gè)Runnable，那就看看在handleCallback(msg)中做了什么。

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

好吧，就是這么簡(jiǎn)單。
再說(shuō)mCallback，它是我們?cè)趧?chuàng)建Handler的時(shí)候在構(gòu)造方法中傳遞的參數(shù)。不過(guò)這個(gè)callback也沒(méi)有啥，除了有一個(gè)返回值的變化。

public interface Callback {
    public boolean handleMessage(Message msg);
}

到此Handler的源碼分析就結(jié)束了。