Android 子線程中更新UI的幾種方法及原理

在開發中我們經常會遇到在子線程中更新ui的操作，那我們今天就介紹下幾種常用的方式

1.使用 runOnUiThread方法更新ui

2.view.post 方法

3.view.postDelaged 方法

4.handler.send...方法更新ui

1.使用 runOnUiThread方法更新ui

這個方法在Activity 中，所以只有在他的子類或者拿到他實例時才能使用

runOnUiThread(new Runnable() {
         @Override
         public void run() {

         }
     });

我們看下runOnUiThread方法的源碼

public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);

        } else {
            action.run();
        }
    }

這裏有個判斷，如果是當前的ui線程那麼就直接執行runnable 的run方法開始更新ui,如果不是就用handler發送posp 消息，我們先看下mHandler是咋回事，通過activity源碼發現它本身new了一個mHandler 就是我們剛纔使用的handrler，如果你瞭解過handrler 源碼你就知道，handrler是會去綁定一個Looper,android應用在啓動的時候就創建了looper 並且開始輪詢，具體看ActiityThead main方法

 public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");
        //獲取主線程的looper對象
        Looper.prepareMainLooper();
        //開啓主線程
        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        //開始消息輪訓
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

到這裏我們知道主線程已將存在， looper已經創建完畢，並開始輪詢消息。現在處於主線程中handler綁定主線程中的looper。瞭解完這些，我們心中大概有個概念了。那繼續看下post方法

 public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

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

看到傳進來的Runnable 方法賦值給了一條消息的callback 接口，然後調用sendMessagDelayed方法，這個方法我們應該比較熟悉了，不就是我們平時使用handler發送消息時調用的方法麼。這個方法最會調用到了sendMessageAtFrontOfQueue(Message msg) 方法，這個比較重要了。

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

首先拿到了當前線程也就是主線程的消息隊列mQueue，如果不知咋回事建議看看下handler原理，這裏就再嘮叨幾句，一個線程中會有一個looper 對象和一個MessageQueue對象可以有多個handler 。然後調用了enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) 方法。

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

然後調用消息隊列的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 指向一個空消息將自身賦值爲mMessages的值
重點理解下第二種情況，假設有三條消息，三條消息對應的when值分別爲3,5,9

假設我們傳進來的msg的when值爲 4，那初次進入參數值爲

1. prev.when=p.when=3

2. p.when=p.next.when= 5

3. xxMessage.when= 9

現在msg.when的值小於p.when=5 ,when<p.when 所以執行了 break方法，那麼msg.next=p 既msg的下一條指向了p,

prev.next=msg 既 prev --> msg--->p---->xxMessage 順利將msg插入到隊列中。

接着我們看下消息的出列操作，前邊我們講過Looper對象， ui線已經創建了looper對象和隊列並且調用了Looper.loop()方法開始輪詢消息出站操作。看下loop()方法。

 public static void loop() {
        //獲取looper對象
        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 (;;) {
            //獲取when值最小的一條消息
            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
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            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 {
                //獲取當前綁定的handler 並且調用其中的dispatchMessage方法，執行handler handlerMessage回調
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            if (slowDispatchThresholdMs > 0) {
                final long time = end - start;
                if (time > slowDispatchThresholdMs) {
                    Slog.w(TAG, "Dispatch took " + time + "ms on "
                            + Thread.currentThread().getName() + ", h=" +
                            msg.target + " cb=" + msg.callback + " msg=" + msg.what);
                }
            }

            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);
            }
            //將當前message 初始化以便重複利用
            msg.recycleUnchecked();
        }
    }

這裏主要有三個點注意，1.隊列是如何獲取when最小的一條消息，2.message是如何重複利用的這兩個我們今天不做探討，我們主要看下 3.run 方法是如何執行或者handlerMessage如何執行的。進入handler 的dispatchMessage方法看下。

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

代碼一目瞭然，如果message設置了callback 那麼執行handlerCallback 方法，否則執行我們熟悉的handlerMesage方法。

這段我們講的是runOnUiThread 傳進來一個接口並且獲取到了Message對象 when賦值爲0 ，msg.callback =Runnable(傳入的接口)

看下handleCallback(Message message) 方法。

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

只有一行代碼，那就是執行run方法。走了這麼大一圈，終於完了。

總結下從runOnUiThread 到run方法執行過程：首先runOnUiThread 方法傳入了一個接口，然後獲取一個message對象，獲取主線程的looper,對列，和handler,然後是消息的入棧操作，接着是消息出棧，獲取當前消息的handler調用消息分發事件dispatchMessage，然後判斷是接口爲空，不爲空的話執行run方法。

2.view.post 方法

接着看下post方法，上面講了那麼多，如果都理解了，下面的相對就非常簡單了。

 mPhotoView.post(new Runnable() {
            @Override
            public void run() {

            }
        });

這個和 runOnUiThread 基本類似，都是傳入一個Runnable接口，看下post（Runnable action）方法。

 public boolean post(Runnable action) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            return attachInfo.mHandler.post(action);
        }

        // Postpone the runnable until we know on which thread it needs to run.
        // Assume that the runnable will be successfully placed after attach.
        getRunQueue().post(action);
        return true;
    }

attachinfo 是當前view 的屬性信息，如果爲空調用隊列的post方法。

attachInfo.mHandler.post(action) 這個是view 本身都會有一個handler 綁定的是主線程的looper ，再看post

 public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

調用到了handler 的sendMessageDelayed（Message msg,long delayMillis）方法我們上邊講過了，接下來他的調用流程和runOnUiThread 一樣了。最後都會執行run方法。

現在看下attactInfo 爲空的情況。

 getRunQueue().post(action);

看下RunQueue是啥

static RunQueue getRunQueue() {
        RunQueue rq = sRunQueues.get();
        if (rq != null) {
            return rq;
        }
        rq = new RunQueue();
        sRunQueues.set(rq);
        return rq;
    }

先通過aRunQueues.get獲取一個Runqueue對象,如果有就返回，沒有就新建一個並調用sRunQueues的set方法,這個不細說，重點看下RunQueue 的post

 void post(Runnable action) {
            postDelayed(action, 0);
        }

        void postDelayed(Runnable action, long delayMillis) {
            HandlerAction handlerAction = new HandlerAction();
            handlerAction.action = action;
            handlerAction.delay = delayMillis;

            synchronized (mActions) {
                mActions.add(handlerAction);
            }
        }

其實是調用了postDelayed方法，我們看到新建了一個HandlerActivity 並且初始化參數，並加入到一個 ArrayList 集合中。那他在哪裏取出hadlerAction 呢。

void executeActions(Handler handler) {
            synchronized (mActions) {
                final ArrayList<HandlerAction> actions = mActions;
                final int count = actions.size();

                for (int i = 0; i < count; i++) {
                    final HandlerAction handlerAction = actions.get(i);
                    handler.postDelayed(handlerAction.action, handlerAction.delay);
                }

                actions.clear();
            }
        }

在當前類中有這麼一個方法，取出了handlerAction 並且調用了handler的postDelayed方法，這個我們比較熟悉，就是最後要執行run方法了。我們重點看下executeAction 何時調用的。在ViewRootlmp 中找到了。performTraversals方法，那麼它又是哪裏調用的呢。

向上追溯， doTraversal（） ---> TraversalRunnable ---> scheduleTraversals 最後到了這裏，這個方法是繪製view了

 boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() ||
                viewVisibility != View.VISIBLE;

        if (!cancelDraw && !newSurface) {
            if (!skipDraw || mReportNextDraw) {
                if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
                    for (int i = 0; i < mPendingTransitions.size(); ++i) {
                        mPendingTransitions.get(i).startChangingAnimations();
                    }
                    mPendingTransitions.clear();
                }

                performDraw();
            }
        } else {
            if (viewVisibility == View.VISIBLE) {
                // Try again
                scheduleTraversals();
            } else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
                for (int i = 0; i < mPendingTransitions.size(); ++i) {
                    mPendingTransitions.get(i).endChangingAnimations();
                }
                mPendingTransitions.clear();
            }
        }

說實話，這個方法調用的地方太多了，一時間還真的難以確認是哪裏調用的，只能大膽猜測下，在view 屬性獲取成功，並且狀態可見時調用。現在算是流程整個通了，梳理下：當沒有獲取到view相關屬性時，就將action存起來（mActions.add(handlerAction)），等到獲取到view相關屬性並且狀態可見時再取出（scheduleTraversals）。

現在看executeActions（方法）調用了handler的postDelayed方法，當然，這個handler也是主線程的，下面流程就是handler那套了，通過判斷是否有接口，執行run方法。

3.view.postDelaged 方法

前面我們講了view.post 方法，如果你仔細觀察，這個方法其實都不用講了。

 public boolean postDelayed(Runnable action, long delayMillis) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            return attachInfo.mHandler.postDelayed(action, delayMillis);
        }
        // Assume that post will succeed later
        ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
        return true;
    }

其實分別調用了handrle的postDelayed 和RunQueue 的postDelayed 方法。而view.post只是對postDelayed的簡單封裝。

attachInfo.mHandler.post(action);

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

attachInfo.mHandler.post(action);


        void post(Runnable action) {
            postDelayed(action, 0);
        }

其他的流程都一樣。

4.handler.send...方法更新ui

上面我們講了幾種更新更新ui的方式，其實歸根到底好是調用了handler的send...方法來更新數據。

但是歸根到底還是調用了 sendMessageAtTime(Message msg, long uptimeMillis) 方法。

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

最後通過enqueueMessage 將消息送入到消息隊列中，然後消息隊列輪行取出消息執行handler中的

public void dispatchMessage(Message msg) 方法，然後執行

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

或者

 handleMessage(msg)

方法，在run 中或在 handleMessage 執行我們的更新ui 的操做。

到這裏更新ui 的幾種方法就介紹完了，本來覺得一天就能搞定的結果搞了四天才寫完，其中又不斷的學習了新的知識，希望大家在看的時候儘量的結合源碼去看，這樣能夠更好的理解。

補充一點，在看資料的時候看到有人說IntentService 和AsyncTask 也可以更新ui 其實他們都是內置了一個子線程然後綁定了一個主線程的Handler實現的。

參考：

https://blog.csdn.net/suma_sun/article/details/51584026

https://blog.csdn.net/lufeng20/article/details/24314381

https://blog.csdn.net/qq_23547831/article/details/50751687

Android 子線程中更新UI的幾種方法及原理

1.使用 runOnUiThread方法更新ui

2.view.post 方法

3.view.postDelaged 方法

4.handler.send...方法更新ui

Android 各系統版本的重要特性4.x-10.0

android 不root 手機如何查看realm 數據庫和SharedPreferences

Realm 你所不知知道的用法

Gson中幾個註解類分析

EventBus使用及源碼解析之註冊

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結

Android 子線程中更新UI的幾種方法 及原理

1.使用 runOnUiThread方法更新ui

2.view.post 方法

3.view.postDelaged 方法

4.handler.send...方法更新ui

Android 子線程中更新UI的幾種方法及原理