Android源碼學習之handler

時間 2019-11-07

原文原文鏈接

前言

想必handler這個東西已經被討論的天花亂墜了，也常常被咱們用在實際開發中，可是其中不少細節知識仍是值得咱們去學習深究的，好比，每一個線程是怎麼保證只有一個looper的，Message消息隊列是經過什麼實現的，handler.sendMessage（）和handler.post（）有什麼區別，handler是怎麼實現跨線程的消息傳遞等等。本篇也僅在源碼的角度來探討下其中的問題，水平有限，錯誤請及時指出。java

文章可能比較長，請耐心閱讀~android

1.基本用法

private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            //doSomething
            super.handleMessage(msg);
        }
    };
複製代碼

Message message = Message.obtain();
message.what=1;
message.obj=new Object();
mHandler.sendMessage(message);
複製代碼

第二種就是post方式面試

new Handler().post(new Runnable() {
            @Override
            public void run() {
                //doSomething
            }
        });
複製代碼

這裏涉及的內存泄漏，先暫不討論，咱們先來看看Handler最基本的構造方法有哪些：bash

Handler()
Handler(Callback callback)
Handler(Looper looper)
Handler(Looper looper, Callback callback)
Handler(boolean async)
Handler(Callback callback, boolean async)
Handler(Looper looper, Callback callback, boolean async)

咱們看重載的最後兩個構造方法就行，由於前面的幾個也是依次調用到後的方法app

public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
複製代碼

一進來就是一個判斷，眼尖的同窗們可能看到了這個log，咦。。這個我好像見過...是的，當這個標誌位位True的時候，這裏會有一個校驗的過程，若是不是靜態的匿名,本地或成員類, 這類可能會產生泄漏，會有一個黃色的警告async

接下來是mlooper的賦值，從Looper.myLooper()取出looper，若是爲空的話，拋出一個異常。。相信這個異常同窗們也多多少少遇到過...扎心了，點進myLooper（）方法：ide

public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }
複製代碼

咦。。這麼簡單嗎，從ThreadLocal對象get出來一個looper，那麼有get，固然有set，looper是何時set進去的呢？咱們在Looper.prepare找到了答案函數

private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }
複製代碼

在調用prepare方法時，當前sThreadLocal裏面的looper不爲空的話，直接拋出異常，這個異常也是蠻常見的...扎心，也就是保證了Looper.prepare（）方法只當前線程能調用一次，注意是當前線程，至於ThreadLocal裏面的邏輯先不討論，後續咱們展開再詳細說，也就是從這裏把looper給set進去了oop

因此在new handler的時候必需要先調用Looper.prepare（）方法，固然，上面的例子是由於主線程中，ActivityThread類已經幫咱們調用了，在子線程中建立handler的時候須要手動調用Looper.prepare（），這裏貼出部分ActivityThread代碼，這裏也是整個應用的入口，源碼位置：/frameworks/base/core/java/android/app/ActivityThread.java，有興趣的能夠去看看post

public static void main(String[] args) {
6042        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
6043        SamplingProfilerIntegration.start();
6044
6045        // CloseGuard defaults to true and can be quite spammy.  We
6046        // disable it here, but selectively enable it later (via
6047        // StrictMode) on debug builds, but using DropBox, not logs.
6048        CloseGuard.setEnabled(false);
6049
6050        Environment.initForCurrentUser();
6051
6052        // Set the reporter for event logging in libcore
6053        EventLogger.setReporter(new EventLoggingReporter());
6054
6055        // Make sure TrustedCertificateStore looks in the right place for CA certificates
6056        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
6057        TrustedCertificateStore.setDefaultUserDirectory(configDir);
6058
6059        Process.setArgV0("<pre-initialized>");
6060
6061        Looper.prepareMainLooper();
6062
6063        ActivityThread thread = new ActivityThread();
6064        thread.attach(false);
6065
6066        if (sMainThreadHandler == null) {
6067            sMainThreadHandler = thread.getHandler();
6068        }
6069
6070        if (false) {
6071            Looper.myLooper().setMessageLogging(new
6072                    LogPrinter(Log.DEBUG, "ActivityThread"));
6073        }
6074
6075        // End of event ActivityThreadMain.
6076        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
6077        Looper.loop();
6078
6079        throw new RuntimeException("Main thread loop unexpectedly exited");
6080    }
複製代碼

另一個構造方法其實就區別於looper的賦值,一個是從當前線程ThreadLocal對象去取looper，一個是從外界賦值

public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
複製代碼

2.發送消息

2.1 handler.sendMessage(）

經過上面，咱們的handler對象就建立出來了，接下來就是發送消息了，咱們先來看看handler.sendMessage（）到底幹了啥：

public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
複製代碼

調用了sendMessageDelayed方法，傳了一個0進去，接着看。。

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

調用了sendMessageAtTime方法，傳入了一個long的毫秒數，接着看。。

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);
    }
複製代碼

這個也很清楚，把msg，uptimeMillis以及以前構造函數拿到的queue塞進去。

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

把當前handler對象賦值給msg.target，調用MessageQueue的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 {
                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;
    }
複製代碼

正主總算來了。。前面先校驗一波，若是handler爲空或者當前msg處於使用中，拋出異常。而後再持有MessageQueue.this鎖，而後將Message放入隊列中，整個流程能夠分爲幾步：

若是當前隊列爲空，或者when等於0（也就是msg對應的時間點），或者msg時間點小於當前隊列頭部的p的時間點，就把咱們傳進來的msg放入隊列首部，不然執行第二步
一個for的死循環，遍歷隊列中Message，找到when比當前Message的when大的Message，將Message插入到該Message以前，若是沒找到則將Message插入到隊列最後
判斷是否須要喚醒，這裏能夠理解爲，若是隊列沒有消息時，當前線程讓出cpu資源，處於一種阻塞狀態，當有消息到達時，須要喚醒next（）函數，具體涉及到jni，後續詳細分析

由此咱們能夠看出來整個隊列消息結構是一種鏈表形式的，這樣只要無限輪詢消息，就可以輕易遍歷除隊列中全部消息

2.2 handler.post()

第二種handler發消息方法：

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

咦。。咱們發現仍是調用的sendMessageDelayed方法，只不過經過getPostMessage方法將Runnable對象轉化爲了msg對象

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

注意這裏的callback，這裏message對象的callback就不爲空了，上述handler.sendMessage(）方法的message對象的callback是爲空的，後續再回調消息中會用到。

3.輪詢消息

咱們知道，android是基本消息機制的，主線程全部的行爲都是由消息機制驅動的，好比activity的什麼週期，點擊事件等等。。。就主線程來講，在上面ActivityThread類中6077行能夠看到Looper.loop（），開啓了消息輪詢機制

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 (;;) {
            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 traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

            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();
        }
    }
複製代碼

代碼基本能看清楚，一個for死循環，不斷的queue.next()，從隊列裏取出消息，而後調用msg.target.dispatchMessage(msg)，這裏的target應該很清楚了，也就是handler對象，能夠對照上面enqueueMessage方法，也就是拿到消息後，回調了到handler的dispatchMessage方法，咱們接着看：

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

終於到這了，相信同窗們也已經很清楚。分幾種狀況：

首先來判斷msg的callback是否爲空，這個在哪裏賦值的呢，對的，對應上面第二種也就是handler.post()形式的傳進來的Runnable對象：

private static void handleCallback(Message message) {
        message.callback.run();
    }
複製代碼

而後回到到run（）方法裏面去，若是爲空走第二種狀況

又是一個判斷若是mCallback不爲空的話，回調handleMessage方法，這裏的mCallback是在handler構造函數賦值的，對應下面的使用用法，但通常這種用法比較少，不然走第三步

new Handler(new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                return false;
            }
        });
複製代碼