Handler機制完全解析

wow_worktile 發(fā)布于2019-08-16 10:49 / 2460人閱讀

摘要：一基本概念什么是消息機制不同線程之間的通信。什么安卓的消息機制，就是運行機制。安卓的消息機制有什么用避免，一旦發(fā)生，程序就掛了，奔潰了。安卓采取的方法是，主線程應(yīng)該為子線程提供一個，以便完成時能夠提交給主線程。

能簡單說得我們盡量不復(fù)雜：

為了避免ANR，我們會通常把耗時操作放在子線程里面去執(zhí)行，因為子線程不能更新UI，所以當(dāng)子線程需要更新的UI的時候就需要借助到安卓的消息機制，也就是Handler機制了。

注意：在安卓的世界里面，當(dāng) 子線程 在執(zhí)行耗時操作的時候，不是說你的主線程就阻塞在那里等待子線程的完成——也不是調(diào)用 Thread.wait()或是Thread.sleep()。安卓采取的方法是，主線程應(yīng)該為子線程提供一個Handler，以便完成時能夠提交給主線程。以這種方式設(shè)計你的應(yīng)用程序，將能保證你的主線程保持對輸入的響應(yīng)性并能避免由于5秒輸入事件的超時引發(fā)的ANR對話框。

一個程序的運行，就是一個進(jìn)程的在執(zhí)行，一個進(jìn)程里面可以擁有很多個線程。


主線程：也叫UI線程，或稱ActivityThread，用于運行四大組件和處理他們用戶的交互。 ActivityThread管理應(yīng)用進(jìn)程的主線程的執(zhí)行(相當(dāng)于普通Java程序的main入口函數(shù))，在Android系統(tǒng)中，在默認(rèn)情況下，一個應(yīng)用程序內(nèi)的各個組件(如Activity、BroadcastReceiver、Service)都會在同一個進(jìn)程(Process)里執(zhí)行，且由此進(jìn)程的主線程負(fù)責(zé)執(zhí)行。
ActivityThread既要處理Activity組件的UI事件，又要處理Service后臺服務(wù)工作，通常會忙不過來。為了解決此問題，主線程可以創(chuàng)建多個子線程來處理后臺服務(wù)工作，而本身專心處理UI畫面的事件。

子線程： 用于執(zhí)行耗時操作，比如 I/O操作和網(wǎng)絡(luò)請求等。（安卓3.0以后要求耗訪問網(wǎng)絡(luò)必須在子線程種執(zhí)行）更新UI的工作必須交給主線程，子線程在安卓里是不允許更新UI的。

一、基本概念

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

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

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

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

在activity中超過5秒的時間未能響應(yīng)下一個事件

BroadcastReceive超過10秒未響應(yīng)

Service超過20秒未響應(yīng)

造成以上兩點的原因有很多，比如網(wǎng)絡(luò)請求, 大文件的讀取, 耗時的計算等都會引發(fā)ANR

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

主線程不能執(zhí)行耗時操作（避免ANR）

子線程不能直接更新UI界面

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

注意：在安卓的世界里面，當(dāng) 子線程在執(zhí)行耗時操作的時候，不是說你的主線程就阻塞在那里等待子線程的完成——也不是調(diào)用 Thread.wait()或是Thread.sleep()。安卓采取的方法是，主線程應(yīng)該為子線程提供一個Handler，以便完成時能夠提交給主線程。以這種方式設(shè)計你的應(yīng)用程序，將能保證你的主線程保持對輸入的響應(yīng)性并能避免由于5秒輸入事件的超時引發(fā)的ANR對話框。

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

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

大概就是說，誰創(chuàng)建的View說更改，別人（子線程）少管閑事。

為什么系統(tǒng)不允許子線程更新UI
因為的UI控件不是線程安全的。
如果在多線程中并發(fā)訪問可能會導(dǎo)致UI控件處于不可預(yù)期的狀態(tài)，那為什么不對UI控件的訪問加上上鎖機制呢？因為有這么兩個缺點：

上鎖會讓UI控件變得復(fù)雜和低效

上鎖后會阻塞某些進(jìn)程的執(zhí)行

對于手機系統(tǒng)來說，這兩個缺點是不可接受的，所以最簡單高效的方法就是 —— 采用單線程模型來處理UI操作。
對開發(fā)者而言也不是很麻煩，只是通過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的簡單使用
既然子線程不能更改界面，那么我們現(xiàn)在就借助Handler讓我們更改一下界面：
主要步驟是這樣子的：
1、new出來一個Handler對象，復(fù)寫handleMessage方法
2、在需要執(zhí)行更新UI的地方 sendEmptyMessage 或者 sendMessage
3、在handleMessage里面的switch里面case不同的常量執(zhí)行相關(guān)操作

附上代碼：

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", "點擊文字");

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

                // 方式一
                //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機制。

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

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

1、Handler發(fā)送消息僅僅是調(diào)用MessageQueue的enqueueMessage向插入一條信息到MessageQueue

2、Looper不斷輪詢調(diào)用MeaasgaQueue的next方法

3、如果發(fā)現(xiàn)message就調(diào)用handler的dispatchMessage，ldispatchMessage被成功調(diào)用，接著調(diào)用handlerMessage()

簡圖

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

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

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

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

MeaasgeQueue源碼)

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

主要插入和讀取兩個操作，這兩個操作對應(yīng)著兩個方法：

插入（入隊） 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方法在這里是一個無限循環(huán)的方法，如果消息隊列里面沒有消息，那么他就會處于阻塞狀態(tài)，當(dāng)有新的消息到來的時，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中文翻譯是輪詢器或者消息泵或者循環(huán)。個人還是叫做輪詢器比較形象一些。

3.1、Looper的作用

Looper是一個輪詢器，它的作用不斷輪詢MessageQueue，當(dāng)如果有新的消息就交給Handler處理，如果輪詢不到新的消息，那就自身就處于阻塞狀態(tài)。

3.2、Looper的構(gòu)造函數(shù)創(chuàng)建了MessageQueue

我們通過查看Loop而這個類，可以發(fā)現(xiàn)的他的構(gòu)造方法里面創(chuàng)建了一個MessageQueue，然后將當(dāng)前線程的對象保存起來

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

3.3、new Handler的hanlder不能沒有Looper

new出來一個Handler但是沒有創(chuàng)建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），被創(chuàng)建的時候就會創(chuàng)建一個Looper

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

3.5、Looper的ThreadLocal

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

Looper 的幾個方法

創(chuàng)建：

Looper.prepare() : 為當(dāng)前線程創(chuàng)建一個Looper

prepareMainLooper() ： UI線程（ActivityThread）創(chuàng)建Looper的

開啟：

Looper.loop() : 開啟消息輪詢

退出

quit() : 直接退出Looper

quitSafely() : 設(shè)定一個標(biāo)記，只有當(dāng)目前已有消息處理完畢之后才會執(zhí)行退出操作。

_注意：當(dāng)Looper退出后，Handler就無法發(fā)送消息，send出去的消息會返回false；當(dāng)我們在子線程中創(chuàng)建了Looper并且所有的消息都處理完畢的時候，要記得調(diào)用 quit 方法，不讓這個Looper就一直處于阻塞狀態(tài)一直那么等待下去_

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

    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方法是一個死循環(huán)，唯一跳出的循環(huán)的方式是MessageQueue的next方法返回null，但是基本上是不可能的。如果我們不手動調(diào)用quit或者quitSafely方法的話，MessageQueue的next方法是不可能返回null的。
因為當(dāng)MessageQueue沒有消息時，next方法會一直阻塞在那里，因為MessageQueue的next方法阻塞了，就導(dǎo)致Looper的loop方法也一直在阻塞了。
這里我們那一分為二的談，

loop輪詢不到消息：那么處于阻塞狀態(tài)，然后就沒有然后了，除了又輪詢到了新的消息

loop輪到了新的消息：Looper就會處理消息

1、msg.target.dispatchMessage(msg)，這里的 msg.targe就是指Handler對象

2、一圈下來，Handler發(fā)送的消息有交給了自己的dispatchMessage方法來處理了。（這個dispatchMessage方法不是Handler自己調(diào)用時，是與Handler相相關(guān)的Looper簡介調(diào)用的），這樣下來，就成功地將邏輯切換到指定的線程當(dāng)中去了

4、Handler的工作原理 4.1、Handler主要工作

主要工作：消息的 發(fā)送 和接受。

4.2、Handler消息發(fā)送的形式

先附上兩份最簡單的日常正常使用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最終還是會調(diào)用send

Handler的部分post和send的源碼

post部分

我們發(fā)現(xiàn)，5個關(guān)于post的方法里面，調(diào)來調(diào)去就是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部分
我們發(fā)現(xiàn)，send相關(guān)的方法也有5個，這5個方法調(diào)用的就是這么幾個方法
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 個方法都進(jìn)入了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個方法加起來調(diào)來調(diào)去也就是另外的4個方法，分別是

sendMessageDelayed （post和send都有調(diào)用）
sendMessageAtTime （post和send都有調(diào)用）
sendMessageAtFrontOfQueue （postAtFrontOfQueue方法一家獨有）
sendEmptyMessageDelayed （sendEmptyMessage方法一家獨占）

我們發(fā)現(xiàn)，sendMessageAtTime和sendMessageAtFrontOfQueue這兩個方法最終都是調(diào)用Handler里面的enqueueMessage方法

sendMessageDelayed調(diào)用了sendMessageAtTime，sendMessageAtTime最后也是調(diào)用enqueueMessage

最曲折的路線，sendEmptyMessageDelayed調(diào)用了sendMessageDelayed，然后sendMessageDelayed sendMessageAtTime，最后sendMessageAtTime調(diào)用enqueueMessage。

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

.
.
小結(jié)

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

剩下1個的獨特的postAtFrontOfQueue方法利用sendMessageAtFrontOfQueue也進(jìn)入了enqueueMessage方法

Handler的enqueueMessage方法調(diào)用了MessageQueue里面的enqueueMessage，enqueueMessage就是讓Hadler通過post或者send發(fā)送過來的Message進(jìn)入到MessageQueue的隊列。

4.3、Handler消息接收的形式

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

1、Handler發(fā)送消息僅僅是調(diào)用MessageQueue的enqueueMessage向插入一條信息到MessageQueue

2、Looper不斷輪詢調(diào)用MeaasgaQueue的next方法

3、如果發(fā)現(xiàn)message就調(diào)用handler的dispatchMessage，ldispatchMessage被成功調(diào)用，接著調(diào)用handlerMessage()

在4.2里面我們看了Handler的發(fā)送相關(guān)代碼，接下來看一下接收的。

dispatchMessage方法

dispatchMessage會判斷三種情況

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

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

2、如果是利用Handler(Callback callback) 構(gòu)造函數(shù)實例化的Handler，也就是構(gòu)造函數(shù)里面?zhèn)魅肓艘粋€CallBack的對象，那么就執(zhí)行這個Callback的handlerMessage。
利用這個接口和Handler的一個構(gòu)造函數(shù)，我們可以這么創(chuàng)建Handler handler=new Handler(callback)來創(chuàng)建Handler;備注寫明了這個接口的作用：可以創(chuàng)建一個Handler的實例但是不需要派生Handler的子類。對比我們?nèi)粘Ｖ凶罱?jīng)常做的，就是派生一個Handler的子類，復(fù)寫handleMessage方法，而通過上面的代碼，我們有了一種新的創(chuàng)建Handler方式，那就是不派生子類，而是通過Callback來實現(xiàn)。

這種方式非常少用。

看一下Handler里面的Callback這個接口的設(shè)計

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

3、如果是send方法發(fā)送的，那么就執(zhí)行handleMessage，這個方法我們非常熟悉了，google的給的備注的也說了，子類必須實現(xiàn)方法以接受這些Message。這也就是我們最常見的最常用的方式了。

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

本篇完。

參考:

《安卓開發(fā)藝術(shù)探索》
Android異步消息處理機制完全解析，帶你從源碼的角度徹底理解

云服務(wù)器 GPU云服務(wù)器 fragment完全解析 handler Handler+線程 Handler分析

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/70531.html

發(fā)表評論

登陸后可評論

0條評論

wow_worktile

男|高級講師

我要關(guān)注我要私信

TA的文章

怎么安裝tensorflow

閱讀 2051·2023-04-25 15:11
利用Calibre軟件設(shè)置郵件一鍵推送電子書教程設(shè)置示范

閱讀 3516·2021-09-23 11:57
騰訊云服務(wù)器2020年2月低價促銷活動,2核4G3M998元/3年

閱讀 1387·2021-07-26 23:38
前端自動化開發(fā)環(huán)境

閱讀 1327·2019-08-30 15:54
content 內(nèi)容生成技術(shù)2

閱讀 645·2019-08-30 15:53
JS執(zhí)行機制

閱讀 3256·2019-08-26 13:36
小程序之仿小米商城Lite

閱讀 997·2019-08-26 12:01
關(guān)于input設(shè)值（value屬性）原生JS以及JQuery的方法比較

閱讀 2873·2019-08-23 16:21

成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

Handler機制完全解析

相關(guān)文章

**安卓中handler原理與生產(chǎn)者消費者模型比較**

發(fā)表評論

0條評論

wow_worktile

男|高級講師

TA的文章

怎么安裝tensorflow

利用Calibre軟件設(shè)置郵件一鍵推送電子書教程設(shè)置示范

騰訊云服務(wù)器2020年2月低價促銷活動,2核4G3M998元/3年

前端自動化開發(fā)環(huán)境

content 內(nèi)容生成技術(shù)2

JS執(zhí)行機制

小程序之仿小米商城Lite

關(guān)于input設(shè)值（value屬性）原生JS以及JQuery的方法比較

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

Handler機制完全解析

相關(guān)文章

發(fā)表評論

0條評論

男|高級講師

TA的文章

最新活動

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！