爲了避免ANR，我們會通常把耗時操作放在子線程裏面去執行，因爲子線程不能更新UI，所以當子線程需要更新的UI的時候就需要藉助到安卓的消息機制，也就是Handler機制了。

注意：在安卓的世界裏面，當子線程在執行耗時操作的時候，不是說你的主線程就阻塞在那裏等待子線程的完成——也不是調用 Thread.wait()或是Thread.sleep()。安卓採取的方法是，主線程應該爲子線程提供一個Handler，以便完成時能夠提交給主線程。以這種方式設計你的應用程序，將能保證你的主線程保持對輸入的響應性並能避免由於5秒輸入事件的超時引發的ANR對話框。

一個程序的運行，就是一個進程的在執行，一個進程裏面可以擁有很多個線程。

主線程：也叫UI線程，或稱ActivityThread，用於運行四大組件和處理他們用戶的交互。 ActivityThread管理應用進程的主線程的執行(相當於普通Java程序的main入口函數)，在Android系統中，在默認情況下，一個應用程序內的各個組件(如Activity、BroadcastReceiver、Service)都會在同一個進程(Process)裏執行，且由此進程的主線程負責執行。
ActivityThread既要處理Activity組件的UI事件，又要處理Service後臺服務工作，通常會忙不過來。爲了解決此問題，主線程可以創建多個子線程來處理後臺服務工作，而本身專心處理UI畫面的事件。

。

子線程：用於執行耗時操作，比如 I/O操作和網絡請求等。（安卓3.0以後要求耗訪問網絡必須在子線程種執行）更新UI的工作必須交給主線程，子線程在安卓裏是不允許更新UI的。

一、基本概念

什麼是消息機制？ —— 不同線程之間的通信。

什麼安卓的消息機制，就是 Handler 運行機制。

安卓的消息機制有什麼用？ —— 避免ANR(Application Not Responding) ，一旦發生ANR，程序就掛了，奔潰了。

什麼時候會觸發ANR？（消息機制在什麼時候用？） —— 以下兩個條件任意一個觸發的的時候就會發生ANR

在activity中超過5秒的時間未能響應下一個事件
BroadcastReceive超過10未響應

造成以上兩點的原因有很多，比如網絡請求, 大文件的讀取, 耗時的計算等都會引發ANR

如何避免ANR
首先明白兩點：

主線程不能執行耗時操作（避免ANR）
子線程不能直接更新UI界面

結合起來這兩點的解決辦法是：把耗時操作放到子線程去執行，然後使用Handler去更新UI

注意：在安卓的世界裏面，當子線程在執行耗時操作的時候，不是說你的主線程就阻塞在那裏等待子線程的完成——也不是調用 Thread.wait()或是Thread.sleep()。安卓採取的方法是，主線程應該爲子線程提供一個Handler，以便完成時能夠提交給主線程。以這種方式設計你的應用程序，將能保證你的主線程保持對輸入的響應性並能避免由於5秒輸入事件的超時引發的ANR對話框。

網絡請求, 大文件的讀取, 複雜的計算等等這些都是耗時操作，耗時操作都應該寫在子線程，但是安卓說了，除了主線程誰都不許更改UI，如果子線程更改UI，就會報出如下錯誤

android.view.ViewRootImpl$CalledFromWrongThreadException: 
Only the original thread that created a view hierarchy can touch its views.

大概就是說，誰創建的View說更改，別人（子線程）少管閒事。

爲什麼系統不允許子線程更新UI
因爲的UI控件不是線程安全的。
如果在多線程中併發訪問可能會導致UI控件處於不可預期的狀態，那爲什麼不對UI控件的訪問加上上鎖機制呢？因爲有這麼兩個缺點：

上鎖會讓UI控件變得複雜和低效
上鎖後會阻塞某些進程的執行
對於手機系統來說，這兩個缺點是不可接受的，所以最簡單高效的方法就是 —— 採用單線程模型來處理UI操作。
對開發者而言也不是很麻煩，只是通過Handler切換一下訪問的線程的就好。

如何手動製造一個ANR呢
在Activitynew一個子線程。睡眠5秒以上，就可以啦。

public class MainActivity extends Activity {

    private TextView mTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTv= (TextView) findViewById(R.id.mTv);
        mTv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("Test", "點擊文字");
                try {
                    Thread.sleep(300000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

    }

}

如何演示子線程不能更改界面呢
給一個TextView弄一個點擊事件，點擊後new一個Thread，在這個線程的run()方法更改TextView的文字，這樣就屬於更改UI了，所以，不行了，掛了。

public class MainActivity extends Activity {

    private TextView mTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTv= (TextView) findViewById(R.id.mTv);
        mTv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("Test", "點擊文字");
                sonThreadUpdateUi();

            }
        });

    }

    private void sonThreadUpdateUi(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                mTv.setText("子線程想要更改界面");
            }
        }).start();
    }

}

子線程更改界面，報錯

報錯如下：

報錯如圖

Handler的簡單使用
既然子線程不能更改界面，那麼我們現在就藉助Handler讓我們更改一下界面：
主要步驟是這樣子的：
1、new出來一個Handler對象，複寫handleMessage方法
2、在需要執行更新UI的地方 sendEmptyMessage 或者 sendMessage
3、在handleMessage裏面的switch裏面case不同的常量執行相關操作

附上代碼：

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.TextView;


public class MainActivity extends Activity {


    private TextView mTv;
    private Handler mHandler;
    private static final int MSG_UPDATE_TEXT = 0x2001; // 更新文本  方式一用的常量
    private static final int MSG_UPDATE_WAY_TWO = 0x2002;  // 更新文本 方式二用的常量

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mHandler=new Handler(){
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what){
                    case MSG_UPDATE_TEXT:
                        mTv.setText("讓Handler更改界面");
                        break;

                    case MSG_UPDATE_WAY_TWO:
                        mTv.setText("讓Handler更改界面方式二");
                        break;
                }
            }
        };



        mTv= (TextView) findViewById(R.id.mTv);
        mTv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d("Test", "點擊文字");

                // 方式一和方式二可以達到相同的效果,就是更改界面

                // 方式一
                //mHandler.sendEmptyMessage(MSG_UPDATE_TEXT);

                // 方式二
                Message msg =Message.obtain();
                msg.what= MSG_UPDATE_WAY_TWO;
                mHandler.sendMessage(msg);


            }
        });

    }

/*    private void sonThreadUpdateUi(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                mTv.setText("子線程想要更改界面");
            }
        }).start();
    }*/

}

附上效果圖：

通過Handler消息機制更新界面

二、消息機制的分析理解

安卓的異步消息處理機制就是handler機制。

主線程，ActivityThread被創建的時候就會創建Looper
Looper被創建的時候創建MessageQueue。
也就是說主線程會直接或簡介創建出來Looper和MessageQueue。
具體創建解釋，參考: Android異步消息處理機制完全解析，帶你從源碼的角度徹底理解(http://blog.csdn.net/guolin_blog/article/details/9991569)

Handler的工作機制簡單來說是這樣的

1、Handler發送消息僅僅是調用MessageQueue的enqueueMessage向插入一條信息到MessageQueue

2、Looper不斷輪詢調用MeaasgaQueue的next方法

3、如果發現message就調用handler的dispatchMessage，ldispatchMessage被成功調用，接着調用handlerMessage()

簡圖

handler簡圖.png

1、Handler的鐵三角—— Handler、MessageQueue和Lopper

android的消息機制就是指Handler機制，Handler機制的運行需要MeeageQueue和Looper的輔助。

注意：我們常常用Handler來更新UI，但是不是說Handler就是把用來更新UI的，我們的耗時的I/O操作，讀取文件，訪問網絡等等都是可以在Handler裏面操作的

2、MessageQueue（消息隊列）的工作原理

MeaasgeQueue源碼

MessageQueue中文翻譯就是消息隊列，它內部存儲了一組信息，存放的是Message，以隊列的形式對外提供了插入和刪除的工作（雖然名字叫做隊列，但是其內部的存儲結構是單鏈表）

主要插入和讀取兩個操作，這兩個操作對應着兩個方法：

插入（入隊） enqueueMessage(Message msg, long when)
讀取（出隊） next()

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

next方法
next方法在這裏是一個無限循環的方法，如果消息隊列裏面沒有消息，那麼他就會處於阻塞狀態，當有新的消息到來的時，next就會返回這條消息並且將其從單鏈表中移除。

Message More ...next() {
128        // Return here if the message loop has already quit and been disposed.
129        // This can happen if the application tries to restart a looper after quit
130        // which is not supported.
131        final long ptr = mPtr;
132        if (ptr == 0) {
133            return null;
134        }
135
136        int pendingIdleHandlerCount = -1; // -1 only during first iteration
137        int nextPollTimeoutMillis = 0;
138        for (;;) {
139            if (nextPollTimeoutMillis != 0) {
140                Binder.flushPendingCommands();
141            }
142
143            nativePollOnce(ptr, nextPollTimeoutMillis);
144
145            synchronized (this) {
146                // Try to retrieve the next message.  Return if found.
147                final long now = SystemClock.uptimeMillis();
148                Message prevMsg = null;
149                Message msg = mMessages;
150                if (msg != null && msg.target == null) {
151                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
152                    do {
153                        prevMsg = msg;
154                        msg = msg.next;
155                    } while (msg != null && !msg.isAsynchronous());
156                }
157                if (msg != null) {
158                    if (now < msg.when) {
159                        // Next message is not ready.  Set a timeout to wake up when it is ready.
160                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
161                    } else {
162                        // Got a message.
163                        mBlocked = false;
164                        if (prevMsg != null) {
165                            prevMsg.next = msg.next;
166                        } else {
167                            mMessages = msg.next;
168                        }
169                        msg.next = null;
170                        if (false) Log.v("MessageQueue", "Returning message: " + msg);
171                        return msg;
172                    }
173                } else {
174                    // No more messages.
175                    nextPollTimeoutMillis = -1;
176                }
177
178                // Process the quit message now that all pending messages have been handled.
179                if (mQuitting) {
180                    dispose();
181                    return null;
182                }
183
184                // If first time idle, then get the number of idlers to run.
185                // Idle handles only run if the queue is empty or if the first message
186                // in the queue (possibly a barrier) is due to be handled in the future.
187                if (pendingIdleHandlerCount < 0
188                        && (mMessages == null || now < mMessages.when)) {
189                    pendingIdleHandlerCount = mIdleHandlers.size();
190                }
191                if (pendingIdleHandlerCount <= 0) {
192                    // No idle handlers to run.  Loop and wait some more.
193                    mBlocked = true;
194                    continue;
195                }
196
197                if (mPendingIdleHandlers == null) {
198                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
199                }
200                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
201            }
202
203            // Run the idle handlers.
204            // We only ever reach this code block during the first iteration.
205            for (int i = 0; i < pendingIdleHandlerCount; i++) {
206                final IdleHandler idler = mPendingIdleHandlers[i];
207                mPendingIdleHandlers[i] = null; // release the reference to the handler
208
209                boolean keep = false;
210                try {
211                    keep = idler.queueIdle();
212                } catch (Throwable t) {
213                    Log.wtf("MessageQueue", "IdleHandler threw exception", t);
214                }
215
216                if (!keep) {
217                    synchronized (this) {
218                        mIdleHandlers.remove(idler);
219                    }
220                }
221            }
222
223            // Reset the idle handler count to 0 so we do not run them again.
224            pendingIdleHandlerCount = 0;
225
226            // While calling an idle handler, a new message could have been delivered
227            // so go back and look again for a pending message without waiting.
228            nextPollTimeoutMillis = 0;
229        }
230    }

3、Looper的工作原理

Looper中文翻譯是輪詢器或者消息泵或者循環。個人還是叫做輪詢器比較形象一些。

3.1、Looper的作用

Looper是一個輪詢器，它的作用不斷輪詢MessageQueue，當如果有新的消息就交給Handler處理，如果輪詢不到新的消息，那就自身就處於阻塞狀態。

3.2、Looper的構造函數創建了MessageQueue

我們通過查看Loop而這個類，可以發現的他的構造方法裏面創建了一個MessageQueue，然後將當前線程的對象保存起來

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

3.3、new Handler的hanlder不能沒有Looper

new出來一個Handler但是沒有創建Looper的話就會報錯。

"Can't create handler inside thread that has not called Looper.prepare()"); ，

解決辦法就是new Handler的時候加上Looper.prepare();

如下代碼中，如果handler2加上Looper.prepare();沒有就會報錯

public class MainActivity extends Activity {   
    private Handler handler1;  
    private Handler handler2;  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        handler1 = new Handler();  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                Looper.prepare();  
                handler2 = new Handler();  
            }  
        }).start();  
    }  

}

3.4、主線程（ActivityThread），被創建的時候就會創建一個Looper

線程默認是沒有Looper的，但是爲什麼在主線程沒有創建的Looper就可以使用Handler？主線程是特別的。主線程，也就是ActivityThread，主線程被創建的時候就會創建一個Looper，這點是比較特殊的，也正因爲這點，所以我們在主線程創建了Handler就直接能用了。

3.5、Looper的ThreadLocal

Looper有一個特殊的概念，那就是ThreadLocal，（他並不是線程），他的作用是幫助Handler獲得當前線程的Looper（多個線程可能有多個Looper）

Looper 的幾個方法

創建：
- Looper.prepare() : 爲當前線程創建一個Looper
- prepareMainLooper() ： UI線程（ActivityThread）創建Looper的

開啓：
- Looper.loop() : 開啓消息輪詢
退出
- quit() : 直接退出Looper
- quitSafely() : 設定一個標記，只有當目前已有消息處理完畢之後纔會執行退出操作。
  
  注意：當Looper退出後，Handler就無法發送消息，send出去的消息會返回false；當我們在子線程中創建了Looper並且所有的消息都處理完畢的時候，要記得調用 quit 方法，不讓這個Looper就一直處於阻塞狀態一直那麼等待下去

Looper這個類裏面最重要的方法就是loop()開啓消息循環這個方法了，看一下代碼：

    Run the message queue in this thread. Be sure to call quit() to end the loop.
108
109    public static void More ...loop() {
110        final Looper me = myLooper();
111        if (me == null) {
112            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
113        }
114        final MessageQueue queue = me.mQueue;
115
116        // Make sure the identity of this thread is that of the local process,
117        // and keep track of what that identity token actually is.
118        Binder.clearCallingIdentity();
119        final long ident = Binder.clearCallingIdentity();
120
121        for (;;) {
122            Message msg = queue.next(); // might block
123            if (msg == null) {
124                // No message indicates that the message queue is quitting.
125                return;
126            }
127
128            // This must be in a local variable, in case a UI event sets the logger
129            Printer logging = me.mLogging;
130            if (logging != null) {
131                logging.println(">>>>> Dispatching to " + msg.target + " " +
132                        msg.callback + ": " + msg.what);
133            }
134
135            msg.target.dispatchMessage(msg);
136
137            if (logging != null) {
138                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
139            }
140
141            // Make sure that during the course of dispatching the
142            // identity of the thread wasn't corrupted.
143            final long newIdent = Binder.clearCallingIdentity();
144            if (ident != newIdent) {
145                Log.wtf(TAG, "Thread identity changed from 0x"
146                        + Long.toHexString(ident) + " to 0x"
147                        + Long.toHexString(newIdent) + " while dispatching to "
148                        + msg.target.getClass().getName() + " "
149                        + msg.callback + " what=" + msg.what);
150            }
151
152            msg.recycleUnchecked();
153        }
154    }

通過代碼我們知道：looper方法是一個死循環，唯一跳出的循環的方式是MessageQueue的next方法返回null，但是基本上是不可能的。如果我們不手動調用quit或者quitSafely方法的話，MessageQueue的next方法是不可能返回null的。
因爲當MessageQueue沒有消息時，next方法會一直阻塞在那裏，因爲MessageQueue的next方法阻塞了，就導致Looper的loop方法也一直在阻塞了。
這裏我們那一分爲二的談，

loop輪詢不到消息：那麼處於阻塞狀態，然後就沒有然後了，除了又輪詢到了新的消息
loop輪到了新的消息：Looper就會處理消息
- 1、msg.target.dispatchMessage(msg)，這裏的 msg.targe就是指Handler對象
- 2、一圈下來，Handler發送的消息有交給了自己的dispatchMessage方法來處理了。（這個dispatchMessage方法不是Handler自己調用時，是與Handler相相關的Looper簡介調用的），這樣下來，就成功地將邏輯切換到指定的線程當中去了

4、Handler的工作原理

4.1、Handler主要工作

主要工作：消息的發送和接受。

4.2、Handler消息發送的形式

先附上兩份最簡單的日常正常使用post和send方式的代碼

send方式sendEmptyMessage方法的小demo

public class MainActivity extends Activity {

    private static final int MSG_CHANGE_TEXT = 0x2001;
    private TextView mTv;

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what){
                case MSG_CHANGE_TEXT:
                    mTv.setText("send方式修改的文字");
                    break;
            }
        }
    };;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTv= (TextView) findViewById(R.id.mTv);
        mTv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                handler.sendEmptyMessage(MSG_CHANGE_TEXT);
            }
        });
    }
}

.
.
post方式的postDelayed方法的小demo

public class MainActivity extends Activity {
    private Handler handler;
    private TextView mTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handler = new Handler();

        mTv = (TextView) findViewById(R.id.mTv);

        mTv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                change();
            }
        });

    }

    private void change(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        mTv.setText("啊哈哈哈");
                    }
                },300);
            }
        }).start();
    }
}

.
.

兩種形式，post和send
其實post最終還是會調用send

Handler的部分post和send的源碼

post部分

我們發現，5個關於post的方法裏面，調來調去就是3個方法
sendMessageDelayed
sendMessageAtTime
sendMessageAtFrontOfQueue （postAtFrontOfQueue方法一家獨有）

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部分
我們發現，send相關的方法也有5個，這5個方法調用的就是這麼幾個方法
sendMessageDelayed
sendMessageAtTime
sendEmptyMessageDelayed （sendEmptyMessage方法一家獨佔）

public final boolean sendMessage(Message msg)
{
        return sendMessageDelayed(msg, 0);
}

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

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

public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
}


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

殊途同歸，最後10 個方法都進入了enqueueMessage方法

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

我們看到，5個post方法，5個send方法，這10個方法加起來調來調去也就是另外的4個方法，分別是

sendMessageDelayed （post和send都有調用）
sendMessageAtTime （post和send都有調用）
sendMessageAtFrontOfQueue （postAtFrontOfQueue方法一家獨有）
sendEmptyMessageDelayed （sendEmptyMessage方法一家獨佔）

我們發現，sendMessageAtTime和sendMessageAtFrontOfQueue這兩個方法最終都是調用Handler裏面的enqueueMessage方法

sendMessageDelayed調用了sendMessageAtTime，sendMessageAtTime最後也是調用enqueueMessage

最曲折的路線，sendEmptyMessageDelayed調用了sendMessageDelayed，然後sendMessageDelayed sendMessageAtTime，最後sendMessageAtTime調用enqueueMessage。

也就是說，除了post方式的postAtFrontOfQueue方法所調用的sendMessageAtFrontOfQueue方法不用postAtTime，
其他的post和send加起來的9個方法都直接或者間接地調用了
postAtTime 方法。

.
.
小結

最終，5個send的方法和5和post的方法，post和send加起來的9個方法都利用postAtTime進入了enqueueMessage方法，

剩下1個的獨特的postAtFrontOfQueue方法利用sendMessageAtFrontOfQueue也進入了enqueueMessage方法

Handler的enqueueMessage方法調用了MessageQueue裏面的enqueueMessage，enqueueMessage就是讓Hadler通過post或者send發送過來的Message進入到MessageQueue的隊列。

4.3、Handler消息接收的形式

再一遍簡要地附上handler工作形式

1、Handler發送消息僅僅是調用MessageQueue的enqueueMessage向插入一條信息到MessageQueue

2、Looper不斷輪詢調用MeaasgaQueue的next方法

3、如果發現message就調用handler的dispatchMessage，ldispatchMessage被成功調用，接着調用handlerMessage()

在4.2裏面我們看了Handler的發送相關代碼，接下來看一下接收的。

dispatchMessage方法

dispatchMessage會判斷三種情況

1、如果是post發送來的message，那麼就讓這個message所持有的Runnable執行run方法，非常簡單。
Message的Callback 是一個Runnable對象，Handler的post的重載的函數不管參數多少，肯定都是有Runnable的。

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

2、如果是利用Handler(Callback callback) 構造函數實例化的Handler，也就是構造函數裏面傳入了一個CallBack的對象，那麼就執行這個Callback的handlerMessage。
利用這個接口和Handler的一個構造函數，我們可以這麼創建Handler handler=new Handler(callback)來創建Handler;備註寫明瞭這個接口的作用：可以創建一個Handler的實例但是不需要派生Handler的子類。對比我們日常中最經常做的，就是派生一個Handler的子類，複寫handleMessage方法，而通過上面的代碼，我們有了一種新的創建Handler方式，那就是不派生子類，而是通過Callback來實現。

這種方式非常少用。

看一下Handler裏面的Callback這個接口的設計

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

3、如果是send方法發送的，那麼就執行handleMessage，這個方法我們非常熟悉了，google的給的備註的也說了，子類必須實現方法以接受這些Message。這也就是我們最常見的最常用的方式了。

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

文／阿敏其人（簡書作者）
原文鏈接：原文鏈接

站內首發文章

Lerch

發佈了5 篇原創文章 · 獲贊 4 · 訪問量 2萬+

私信關注

Handler機制詳解

一、基本概念

二、消息機制的分析理解

1、Handler的鐵三角—— Handler、MessageQueue和Lopper

2、MessageQueue（消息隊列）的工作原理

3、Looper的工作原理

3.1、Looper的作用

3.2、Looper的構造函數創建了MessageQueue

3.3、new Handler的hanlder不能沒有Looper

3.4、主線程（ActivityThread），被創建的時候就會創建一個Looper

3.5、Looper的ThreadLocal

4、Handler的工作原理

4.1、Handler主要工作

4.2、Handler消息發送的形式

4.3、Handler消息接收的形式

dispatchMessage方法

Android項目JNI層C/C++文件中添加LOG信息

Acitivity啓動模式

Android AsyncTask原理-源碼層分析

Handler機制詳解

Glide和Picasso

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Handler機制詳解

一、 基本概念

二、消息機制的分析理解

1、Handler的鐵三角—— Handler、MessageQueue和Lopper

2、MessageQueue（消息隊列）的工作原理

3、Looper的工作原理

3.1、Looper的作用

3.2、Looper的構造函數創建了MessageQueue

3.3、new Handler的hanlder不能沒有Looper

3.4、主線程（ActivityThread），被創建的時候就會創建一個Looper

3.5、Looper的ThreadLocal

4、Handler的工作原理

4.1、Handler主要工作

4.2、Handler消息發送的形式

4.3、Handler消息接收的形式

dispatchMessage方法

一、基本概念