很早之前就Handler的分析，不過感覺有點亂亂的，所以趁著有時間就將其改了改。
　　
　　Handler是我們android開發中經常使用的一個類，一般我們在子線程中做了耗時操作后使用handler來發送一個消息到主線程中去刷新UI，因為Android要求UI的刷新必須在主線程中來執行，所以使用handler來實現我們的目的是非常方便的。我們一般會使用handler來做刷新UI的操作，但是handler提供的功能可不僅僅只是在UI線程中來處理，它也可以子線程中處理消息。說起Handler一般都會和Looper、Message、MessageQueue聯系起來，Looper是一個循環器不停的從MessageQueue中Message息交給Handler來處理。
　　我們一般使用的時候就是直接new Handler()然后覆寫handleMessage()方法就可以在主線程中處理任務了。為什么沒有看到Looper和MessageQueue的身影了，如果我們在子線程中去new Handler()會發生什么情況呢？
　　下面我們從源碼的角度來看看handler是怎么工作的。

我們知道，Android應用啟動的入口在ActivityThread這個類，里面就能看到看到我們在學習java的時候main函數的身影，在main方法中，會自動在線程中初始化Looper，所以我們在主線程中去new Handler()的時候是不需要關心這個的，因為已經幫我們做好了。我們先來看看main方法中到底做了什么：

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

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

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

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

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

看到Looper里面也沒有神秘的東西，還是挺簡單的，Looper里面使用了一個ThreadLocal，它能夠提供線程獨立的數據，線程之間使用ThreadLocal保存的數據互不干擾，對于不清楚ThreadLocal的可以參考ThreadLocal源碼分析
可以看到prepareMainLooper只是創建了一個looper對象跟主線程關聯起來。

public static void loop() {
    //當前線程為主線程，所以取到的looper就是一個主線程中的looper
    final Looper me = myLooper();
    if (me == null) {
        //這里告訴我們，如果在子線程中使用looper的話，不調用Looper.prepare()是會gg的，看到這個異常是不是很熟悉啊
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    //在Looper的構造方法中就會初始化一個MeesageQueue對象，就一行代碼，這里就不貼了
    final MessageQueue queue = me.mQueue;
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    for (;;) {
        //如果MeesageQueue沒有消息，這里會阻塞等待知道有消息過來
        Message msg = queue.next(); // might block
        if (msg == null) {
            //如果這里為null，說明MessageQueue停止運行了，也就不能處理主線程的邏輯了，程序就退出了
            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對象，然后調用handler.dispatchMessage()方法
            //在handler發送消息的時候，會將自己也封裝在message中，所以這里我們才能處理消息
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        ...
        msg.recycleUnchecked();
    }
}

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

我們先從sendMessage()這里說起，它是我們發消息的出發點。

//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里面封裝了好幾種發送消息的方法，但是最終它們調用enqueueMessage()，所以我們來看看它里面到底是怎么實現的

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

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

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

到這里，是不是感覺整個Handler的流程一下就頓悟了很多。
我們接著上面的說，在looper中最終會調用我們的handler的dispatchMessage()方法，來看看：

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

看到了啥，handleMessage()竟然是在這里被調用的，一下子又哦哦哦了。
不過發現handleMessage()是最好才被處理的。那前面幾個callback是什么呢？
先說msg.callback()，除了handler提供了幾個sendxxxMessage()方法外，還提供了幾個post方法來發送消息。

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

竟然還是調用了我們的send方法來發送消息，簡直了就是。不過這里的message好像有點不一樣，看看這里做了什么。

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

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

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

好吧，就是這么簡單。
再說mCallback，它是我們在創建Handler的時候在構造方法中傳遞的參數。不過這個callback也沒有啥，除了有一個返回值的變化。

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

到此Handler的源碼分析就結束了。