Handler機制完全解析

wow_worktile 發布于2019-08-16 10:49 / 2451人閱讀

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

能簡單說得我們盡量不復雜：

為了避免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秒未響應

Service超過20秒未響應

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

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

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

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

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

網絡請求, 大文件的讀取, 復雜的計算等等這些都是耗時操作，耗時操作都應該寫在子線程，但是安卓說了，除了主線程誰都不許更改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機制。

主線程，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()

簡圖

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

本篇完。

參考:

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

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

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/70531.html

安卓中handler原理與生產者消費者模型比較

摘要：本文主要說明內部消息機制用模擬進行演示并用圖簡單說明并與生產者與消費者模型進行比對代碼地址需要解決的問題主線程怎樣跟子線程進行通信子線程生產的資源如何傳給主線程子線程如何進行等待完成耗時操作才給主線程傳遞消息為何只能在主線程才能創建子線程想本文主要說明android內部消息機制,用java模擬進行演示,并用圖簡單說明.并與生產者與消費者模型進行比對; git代碼地址需要解決的問題:...

TNFE 2019-08-16 13:46 評論0 收藏0

發表評論

登陸后可評論

0條評論

wow_worktile

男|高級講師

我要關注我要私信

TA的文章

怎么安裝tensorflow

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

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

閱讀 1372·2021-07-26 23:38
前端自動化開發環境

閱讀 1319·2019-08-30 15:54
content 內容生成技術2

閱讀 635·2019-08-30 15:53
JS執行機制

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

閱讀 986·2019-08-26 12:01
關于input設值（value屬性）原生JS以及JQuery的方法比較

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

国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

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

Handler機制完全解析

相關文章

**安卓中handler原理與生產者消費者模型比較**

發表評論

0條評論

wow_worktile

男|高級講師

TA的文章

怎么安裝tensorflow

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

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

前端自動化開發環境

content 內容生成技術2

JS執行機制

小程序之仿小米商城Lite

關于input設值（value屬性）原生JS以及JQuery的方法比較

最新活動

資訊專欄INFORMATION COLUMN

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

Handler機制完全解析

相關文章

發表評論

0條評論

男|高級講師

TA的文章

最新活動

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