android 重要核心知識點，怎麼深刻理解都不為過,本篇部落格從常用api ，Looper Hanldery以及HanlderTread原始碼角度解讀

一 常用api，主執行緒接收處理訊息

 private Handler handler = new Handler() {
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 1 :
                bt.setText("正在下載...");
                break;
            case
 
 2 :
                Bitmap bm = (Bitmap) msg.obj;
                iv.setImageBitmap(bm);
                break;
            case 3 :
                Bundle bundle = msg.getData();
                String data = bundle.getString("text");
                bt.setText(data);
                break;
        }
    }
};
 

二 子執行緒傳送訊息

send傳送

Message msg=new Message();
msg.what=1;//魔鬼數字，避免
handler.sendMessage(msg);
//或者
sendMessageDelay(what);
//或者
sendEmptyMessage(what);
//如果要帶一個obj
Message msg = new Message(); 
msg.what =2; 
msg.obj = bm; 
handler.sendMessage(msg);
//帶一個bundle
Message msg = new Message(); 
Bundle data = new
 
 Bundle(); 
data.putString("text", "正在下載..."); 
msg.what = 3; 
msg.setData(data); 
handler.sendMessage(msg);
//通過obtainMessage能避免重複Message建立物件

handler.sendEmptyMessage(1);
handler.sendEmptyMessageDelayed(1,1000);
handler.sendEmptyMessageAtTime(1,1000);
handler.sendMessage(Message.obtain());
handler.sendMessageAtTime(Message.obtain(),100);
handler.sendMessageDelayed(Message.obtain(),100);

post傳送

mHandler.post(new Runnable()  
        {  
            @Override  
            public void run()  
            {  
                Log.e("TAG", Thread.currentThread().getName());  
                mTxt.setText("yoxi");  
            }  
        }); //並未建立執行緒,與handler同一個執行緒當然還有postDelayed方法

三 handler looper message 三者之間關係，逐個分析

3.1 Looper

Looper負責建立一個MessageQueue，然後進入一個無限迴圈體，不斷從MessageQueue讀取訊息，訊息的建立者就是Handler
Looper主要是prepare()和loop方法，

public static final void prepare() {  
        if (sThreadLocal.get() != null) {  
            throw new RuntimeException("Only one Looper may be created per thread");  
        }  
        sThreadLocal.set(new Looper(true));  
} 

sThreadLocal是一個ThreadLocal物件，可以在一個執行緒中儲存變數。可以看到，在第5行，將一個Looper的例項放入了ThreadLocal，並且2-4行判斷了sThreadLocal是否為null，否則丟擲異常。這也就說明了Looper.prepare()方法不能被呼叫兩次，同時也保證了一個執行緒中只有一個Looper例項.ActivityThread的main函式中呼叫prepare方法
Looper構造器

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

在構造方法中，建立了一個MessageQueue（訊息佇列）。
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  
                Printer logging = me.mLogging;  
                if (logging != null) {  
                    logging.println(">>>>> Dispatching to " + msg.target + " " +  
                            msg.callback + ": " + msg.what);  
                }  

                msg.target.dispatchMessage(msg);  

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

第2行：
public static Looper myLooper() {
return sThreadLocal.get();
}

方法直接返回了sThreadLocal儲存的Looper例項，如果me為null則丟擲異常，也就是說looper方法必須在prepare方法之後執行。

第6行：拿到該looper例項中的mQueue（訊息佇列）
13到45行：就進入了我們所說的無限迴圈。
14行：取出一條訊息，如果沒有訊息則阻塞。
27行：使用呼叫 msg.target.dispatchMessage(msg);把訊息交給msg的target的dispatchMessage方法去處理。Msg的target是什麼呢？其實就是handler物件，下面會進行分析。
44行：釋放訊息佔據的資源。

Looper主要作用：
1、 與當前執行緒繫結，保證一個執行緒只會有一個Looper例項，同時一個Looper例項也只有一個MessageQueue。
2、 loop()方法，不斷從MessageQueue中去取訊息，交給訊息的target屬性的dispatchMessage去處理。

3.2 handler

好了，我們的非同步訊息處理執行緒已經有了訊息佇列（MessageQueue），也有了在無限迴圈體中取出訊息的哥們，現在缺的就是傳送訊息的物件了，於是乎：Handler登場了。看原始碼

public Handler() {  
        this(null, false);  
}  
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;  
    } 

構造方法中： 14行：通過Looper.myLooper()獲取了當前執行緒儲存的Looper例項，然後在19行又獲取了這個Looper例項中儲存的MessageQueue（訊息佇列），這樣就保證了handler的例項與我們Looper例項中MessageQueue關聯上了。

send訊息時： 所有的message的send方法 sendMessage(Message msg) ，sendEmptyMessageDelayed(int what, long delayMillis)
sendMessageDelayed(Message msg, long delayMillis)
都會走到sendMessageAtTime，在此方法內部有直接獲取MessageQueue然後呼叫了enqueueMessage方法，我們再來看看此方法：

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;  
       if (mAsynchronous) {  
           msg.setAsynchronous(true);  
       }  
       return queue.enqueueMessage(msg, uptimeMillis);  
   } 

enqueueMessage中首先為msg.target賦值為this，【如果大家還記得Looper的loop方法會取出每個msg然後交給msg,target.dispatchMessage(msg)去處理訊息】，也就是把當前的handler作為msg的target屬性。最終會呼叫queue的enqueueMessage的方法，也就是說handler發出的訊息，最終會儲存到訊息佇列中去。
保證了handler的例項與我們Looper例項中MessageQueue關聯上了。

現在已經很清楚了Looper會呼叫prepare()和loop()方法，在當前執行的執行緒中儲存一個Looper例項，這個例項會儲存一個MessageQueue物件，然後當前執行緒進入一個無限迴圈中去，不斷從MessageQueue中讀取Handler發來的訊息。然後再回調建立這個訊息的handler中的dispathMessage方法，下面我們趕快去看一看這個方法：

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

這樣就到了handlerMessge方法，回撥 ok

總結

1、Looper.prepare()呼叫Looper構造器，Looper 構造器new一個MessageQueue，例項化處一個執行緒。prepare方法只能呼叫一次，然後該例項中儲存一個MessageQueue物件；因為Looper.prepare()在一個執行緒中只能呼叫一次，所以MessageQueue在一個執行緒中只會存在一個。

2、Looper.loop()會讓當前執行緒進入一個無限迴圈，不斷從MessageQueue的例項中讀取訊息，然後回撥msg.target.dispatchMessage(msg)方法。

3、Handler的構造方法中，Loop.myLooper()會首先得到當前執行緒中儲存的Looper例項，進而與Looper例項中的MessageQueue相關聯。

4、Handler的send方法，會給msg的target賦值為handler自身，然後將message加入MessageQueue中。

5、在構造Handler例項時，我們會重寫handleMessage方法，也就是msg.target.dispatchMessage(msg)最終呼叫的方法。

好了，總結完成，大家可能還會問，那麼在Activity中，我們並沒有顯示的呼叫Looper.prepare()和Looper.loop()方法，為啥Handler可以成功建立呢，這是因為在Activity的啟動程式碼中，已經在當前UI執行緒ActiveityThread呼叫了Looper.prepare()和Looper.loop()方法。
簡化如下：

Looper，prepare方法threadLocal保證一個執行緒只有一個looper例項，構造方法中建立msgqueue，loop無限迴圈方法，msgqueue.next 取出訊息，msg.target.dispatchMessage ,把訊息交給target的dispatchmessage方法處理，hanlder構造方法中Looper靜態方法獲取當前執行緒儲存的Looper例項，（訊息輪詢和處理都在主執行緒）， sendMessage方法無論是否延遲都會走到sendMesageAtTime –>enqueueMessage方法 將this賦值給msg.target 。handler傳送的訊息儲存到訊息佇列中，dispatchMessage中呼叫handleMessage