handler消息機制

時間 2020-09-21

標籤 handler 消息機制简体版

原文原文鏈接

MessageQueue代碼：http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/MessageQueue.java/?v=sourcejava

Handler代碼：android

http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/Handler.java/?v=sourcegit

Looper代碼：github

http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/Looper.java/?v=sourceless

爲何有handler,handler的主要做用是什麼？異步

首先android UI主線程不能進行大量的耗時操做，不然會產生ANR以及很差的UI體驗，所以必須經過異步的方式處理耗時的操做，避免耗時的操做阻塞UI主線程。async

handler的主要做用是什麼呢，主要負責多個線程之間的信息通訊，好比子線程中中耗時操做返回結果須要在UI線程進行展現，這時候就須要經過handler來將消息傳遞到UI線程並刷新UI內容。ide

handler的消息機制主要牽扯三方面：oop

消息發送者；
消息隊列；
消息處理循環操做。

handler發消息有兩種方式：post

send
1. sendEmptyMessage(int)，發送一個空的消息;
2. sendMessage(Message)，發送消息，消息中能夠攜帶參數;
3. sendMessageAtTime(Message, long)，將來某一時間點發送消息;
4. sendMessageDelayed(Message, long)，延時Nms發送消息。
post
1. post(Runnable)，提交計劃任務立刻執行;
2. postAtTime(Runnable, long)，提交計劃任務在將來的時間點執行;
3. postDelayed(Runnable, long)，提交計劃任務延時Nms執行。

messageQueue：消息隊列，對外提供插入和刪除的工做，內部存儲結構爲單鏈表結構。

messageQueue的兩個主要方法：

enqueueMessage:向消息隊列中插入元素；
next：從消息隊列中取出元素，是個無線循環的方法，無消息，阻塞，有消息，返回消息並從消息隊列中將消息移除。

looper:用來構建輪訓消息隊列系統。

線程默認沒有looper,使用handler就必須爲線程建立looper。

Looper.prepare()建立Looper;
Looper.loop()開啓消息循環;
Looper.prepareMainLooper()主線程建立looper;
quit:直接退出Looper;
quitSafely:設定退出標誌，已有消息處理完之後纔會退出。

消息發送：post方式發送消息的方式最後調用的仍是sendMessage方式：

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

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

往下走：

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

最後走到這裏:

public boolean More ...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 在消息隊列中插入一條消息，在 enqueueMessage總中，會把 msg.target 設置爲當前的Handler 對象。

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

以下將消息插入消息隊列中去。而且能夠很明顯看出消息隊列是線性鏈表結構。

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("MessageQueue", 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;
}

每一個線程只能運行一個looper對象，建立 Looper 的時候，內部會建立一個消息隊列MessageQueue;而且looper在線程裏面必須先prepare(),再loop來對消息隊列messageQueue來進行遍歷循環操做。

public static void loop() {
        final Looper me = myLooper();
        //若是looper對象是空的，就提示必須在當前線程經過looper.prepare()來進行建立
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //若是looper不爲null,就取出消息隊列
        final MessageQueue queue = me.mQueue;

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        //遍歷消息隊列
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                //沒有消息中斷操做，跳出循環
                return;
            }

            //----------------隊列不爲null的操做----------------
            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            //----------------隊列不爲null，分發數據出去---------------- msg.target.dispatchMessage(msg); if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

循環遍歷並分發消息出去msg.target.dispatchMessage(msg)，切換到建立handler所使用的looper中執行，也就是說將邏輯切換到主線程去：

/**
     * Handle system messages here.
     *首先，若是消息的 callback 不是空，便調用 handleCallback 處理。不然判斷 Handler 的 mCallback 是否爲空，不爲空則調用它的 handleMessage方法。若是仍然爲空，才調用 Handler 自身的 handleMessage，也就是咱們建立 Handler 時重寫的方法 */
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //回調handler的handleMessage(msg)方法，從而接收數據  handleMessage(msg);
    }
}

額，先寫到這，明天繼續更新。

hander的相關問題的延伸：

handler在實際開發中常見的問題就是內存泄漏的問題了：

常見的寫法：

 private Handler   handler    = new Handler() { public void handleMessage(android.os.Message msg) { switch (msg.what) {
                case UPDATE_TEXTVIEW:
                    updateTextView();
                    break;

                default:
                    break;
            }
        }
    };

1，在Java中，非靜態的內部類和匿名內部類都會隱式地持有其外部類的引用，靜態的內部類不會持有外部類的引用，經過將類聲明爲靜態的，解決持有外部類引用的問題；

2，android主線程有looper,looper處理MessageQueue消息隊列數據的進進出出，Message添加到消息隊列中的時候Message(排隊的Message)會持有當前Handler引用,處理消息，並在ui界面上進行結果展現或者toast()或者dialog對話框彈出，就會產生MessageQueue 到 Message 到 Handler 到 Activity的引用鏈。

爲了解決靜態內部類沒法操做外部類的內容，將activity做爲弱引用引入，這樣就就能夠避免引用的問題，有能夠對外部類的方法進行調用。

那麼如何解決呢？

private Handler   handler    = new MyHandler( BackPasswordActivity.this );

    private class MyHandler extends Handler {
        private WeakReference<Activity> mActivity;


        public MyHandler(BackPasswordActivity activity) {
            mActivity = new WeakReference<Activity>( activity );
        }


        @Override public void handleMessage(Message msg) {
            super.handleMessage( msg );
            MainActivity activity = (MainActivity) mActivity.get();
            if (activity != null) updateTextView();
        }
    }

還有一種解決方式：WeakHandler

開源庫地址：https://github.com/badoo/android-weak-handler

實際項目中使用:

1,引入：compile 'com.badoo.mobile:android-weak-handler:1.1'，固然也能夠代碼引入，就一個類；

2，代碼中的使用：

聲明以及在主線程中接收消息，注意和咱們的handler的寫法的不一樣：

 WeakHandler myHandler = new WeakHandler(new Handler.Callback() { @Override public boolean handleMessage(Message msg) { switch (msg.what) {
                    case 1:
                        //UI操做
                        if (!StringUtil.isEmpty(tradeNo)) {
                            rechargeStatus();
                        }
                        break;
                    default:
                        break;
                }
                return false;
            }
        });

發送消息：

    Message message = new Message();
    message.what = 1;
    myHandler.sendMessage(message);  //發送message

相關標籤/搜索