# 前言

![](https://upload-images.jianshu.io/upload_images/27242968-31b738c642a1ae95?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

典型的生產者-消費者模式。Android跨程式要掌握的是Binder，而同一程式中最重要的應該就是Handler訊息通訊機制了。我這麼說，大家不知道是否認同，如果認同，還希望能給一個關注哈。

### Handler是什麼

Handler主要用於非同步訊息的處理：當發出一個訊息之後，首先進入一個訊息佇列，傳送訊息的函式即刻返回，而另外一個部分在訊息佇列中逐一將訊息取出，然後對訊息進行處理，也就是傳送訊息和接收訊息不是同步的處理。這種機制通常用來處理相對耗時比較長的操作。

### Handler怎麼用

```
public class HandlerActivity extends AppCompatActivity {
    private static final String TAG = "HandlerActivity";
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        testSendMessage();
    }

public void testSendMessage() {
         Handler handler = new MyHandler(this);
         Message message = Message.obtain();
         message.obj = "test handler send message";
         handler.sendMessage(message);
    }

//注1： 為什麼要用靜態內部？？？
    static class MyHandler extends Handler {
        WeakReference<appcompatactivity> activityWeakReference; // 注2：為何要用弱引用？？？
        public MyHandler(AppCompatActivity activity) {
            activityWeakReference = new WeakReference<>(activity);
        }

@Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            Log.d(TAG, (String) msg.obj);
        }
    }
}
```

# Handler原始碼怎麼解讀

從使用方式的場景，我們們一步一步的探究裡面是怎麼實現的，還有上面的標註的兩點，在後面我都會介紹的，各位客官聽我慢慢道來。first，看下四大金剛關係圖，文字表述再多，不如一張圖來的直接。

![](https://upload-images.jianshu.io/upload_images/27242968-2912bda536e93736?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

透過上圖就可以簡單看出Handler、MessageQueue、Message、Looper 這四者是怎麼樣互相持有對方的，大概可以瞭解訊息的傳遞。next，我們先來一張時序圖，看下訊息是怎麼一步步傳送出來的。

![](https://upload-images.jianshu.io/upload_images/27242968-4d14bbeb1845a9e4?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

1.  進入的是Handler.sendMessage方法。

```
public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0);
}
```

2.  接下來繼續呼叫Handler.sendMessageDelayed方法。

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

3.  接著走Handler.sendMessageAtTime 方法，這裡面就要用到MessageQueue 物件了，此處說明一下，這個mQueue  是在哪裡獲取到的，是在Handler 構造方法裡。此處貼圖，從圖中可以看出mLooper=Looper.myLooper() mQueue=mLooper.mQueue。Handler 中的MessageQueue是Looper中持有的MessageQueue物件 。

![](https://upload-images.jianshu.io/upload_images/27242968-278405e41c51d474?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

注1：為啥要用靜態內部類----> 如果我們使用Handler 類，沒有用static 關鍵字修飾的話，則會輸出Log：The following Handler class should be static or leaks might occur。會提示你可能會引起記憶體洩漏。因此在注1處我用了static修飾。

```
public boolean sendMessageAtTime(@NonNull 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);
}
```
4.  接著時序圖上的流程走，此時要進入到MessageQueue.enqueueMessage 方法中，該方法就是將msg物件存入到MessageQueue佇列中，注意此處，將該handler物件賦值給了msg.target，這個後面會用到的，很關鍵。

```
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis); //3，即將進入MessageQueue.enqueueMessage 方法。
}
```

5.  接著來看MessageQueue.enqueueMessage方法，該方法就是按照時間的順序插入到Message這個連結串列結構的資料物件中去。

```
boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) { //4. 後面說明，這個也就是四大金剛圖裡的msg.target 所持有的Handler 物件。
        throw new IllegalArgumentException("Message must have a target.");
    }

synchronized (this) {
        ...
        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); //畫重點，此處喚醒等待的next 方法。
        }
    }
    return true;
}
```

此時，一條訊息就相當於入隊了。MessageQueue從名稱來看是佇列，實際上，使用的還是Message.next指標來進行操作的，也即是連結串列的操作。訊息的入隊完成，後面將會介紹該訊息是怎麼傳送出去的。6\. Loop.loop方法，敲重點。省略了部分程式碼，只關注核心程式碼。這裡用到了死迴圈，不停的獲取Message物件，獲取到之後直接呼叫Message.target變數所持有的Handler物件，然後呼叫Handler.dispatchMessage方法，這樣就完成了訊息的分發。

```
public static void loop() {
    final Looper me = myLooper();
    ...
    final MessageQueue queue = me.mQueue;
    ...
    for (;;) {
        Message msg = queue.next(); // might block   //7.透過MessageQueue.next()方法獲取Message物件。
        ...
        final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        final long end;
        try {
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        ...
        msg.recycleUnchecked();
    }
}
```

7-8\. MessageQueue.next()方法獲取Message物件。

```
Message next() {
    ...
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) { //死迴圈
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

nativePollOnce(ptr, nextPollTimeoutMillis);   // 5: 避免了阻塞的關鍵點，釋放資源，處於等待。疑點：處於等待，肯定需要一個東西來喚醒它。上面第5步分析enqueueMessage的時候有行程式碼if (needWake) {
            nativeWake(mPtr); //畫重點，此處喚醒等待的next 方法。
        } 。

synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) { //******此條件可以先不看，因為透過Handler 傳送的訊息target 都會持有Handler，該邏輯不會觸發。訊息同步屏障的時候會優先觸發該邏輯。
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) { //查詢當前的msg 物件。
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    mBlocked = false;
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }
         ...
        nextPollTimeoutMillis = 0;
    }
}
```

9.Handler.dispatchMessage方法，此處有判斷，如果在Activity中使用view.post方法呼叫的時候，就會走到handleCallback回撥中。透過sendMessagexxx函式傳送訊息的就會走到handleMessage回撥中去。

```
/**
 * Handle system messages here.
 */
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}
```

該方法會會將msg物件傳送到客戶端定義Handler的地方，重寫的handleMessage方法。至此，Handler傳送訊息的流程大致介紹完成。

## 總結

Handler 傳送訊息的時候，在Handler.enqueueMessage方法中，將該Handler物件新增到Message中的target屬性中，這樣就完成了Message持有Handler的操作，為最後Message.target.dispatchMessage做了保證。

然後將該Message物件放入到MessageQueue中的Message.next中去，完成了訊息連結串列的新增；而這個MessageQueue是Looper中所持有的物件，這樣就可以透過Looper類透過對MessageQueue.next()---->Message.next()--->Message.target.dispatchMessage(msg)完成了訊息的分發。

![](https://upload-images.jianshu.io/upload_images/27242968-01e8384ce544dd36?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## 補充點

##### **Looper物件是怎麼new出來的？**

![](https://upload-images.jianshu.io/upload_images/27242968-38d5a05ca8475d1d?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

上圖看出是在應用程式程式的ActivityThread類中的main()函式中呼叫了Looper.prepareMainLooper()方法，就new出來了主執行緒中的Looper。

![](https://upload-images.jianshu.io/upload_images/27242968-494e4c2cb854c851?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

上圖也看出，這個Looper.prepareMainLooper()方法是系統呼叫的，開發者不能再次呼叫了，否則會丟擲異常。

![](https://upload-images.jianshu.io/upload_images/27242968-0bad4e17c46f5128?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

prepare這個方法真正的new Looper了。接著來看看Looper的建構函式。

![](https://upload-images.jianshu.io/upload_images/27242968-4b2f51dad919557c?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

此處建立了MessageQueue，Handler中的MessageQueue就是這塊建立的。

##### **為什麼將Looper儲存在ThreadLocal中？**

ThreadLocal：執行緒的變數副本，每個執行緒隔離。我的理解就是，ThreadLocal內部使用了當前執行緒為Key，需要儲存的物件為Value，透過字典儲存起來的，這樣客戶端在獲取的時候，當前執行緒就只會獲取一份儲存的Value。回到Looper中，就可以知道一個執行緒裡按理說就會只有一個Looper。

##### **Message 為什麼推薦使用obtain()方式獲取Message物件，而不推薦使用new Message()？**

這裡涉及到池的技術的應用：Message中維護了一個訊息池，訊息使用完就會回收。減少物件建立和銷燬的開銷；java當中的執行緒池也是用到了該思想。

##### **同步屏障**

同步屏障機制的作用，是讓這個繪製訊息得以越過其他的訊息，優先被執行。系統中UI繪製會使用到同步屏障，開發中基本用不到。核心程式碼是先設定一個target=null的訊息，插入到訊息連結串列的頭部。

![](https://upload-images.jianshu.io/upload_images/27242968-6e4afcc941bdcedd?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

然後在MessageQueue.next中優先查詢同步屏障中的訊息asyncHronous設定為true的非同步訊息。

![](https://upload-images.jianshu.io/upload_images/27242968-5bc1690b26ff13db?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

##### **Handler為什麼會導致記憶體洩漏以及解決方案？**

Handler導致記憶體洩漏一般發生在傳送延遲訊息的時候，當Activity關閉之後，延遲訊息還沒發出，那麼主執行緒中的MessageQueue就會持有這個訊息的引用，而這個訊息是持有Handler的引用，而handler作為匿名內部類持有了Activity的引用，所以就有了以下的一條引用鏈。

**解決**

1.  使用靜態內部類，如果要呼叫Activity中的方法，就可以在靜態內部類中設定一個WeakReference activityWeakReference引用。
2.  在Activity銷燬的時候，即onDestory()方法中呼叫handler.removeCallbacks，移除runnable。</appcompatactivity>

扒光 Handler，趕緊來瞧一瞧

相關文章