檢視下面一段程式碼

public class SampleActivity extends Activity {

  private final Handler mLeakyHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      // ... 
    }
  };
}

上面一段程式碼看起來很正常，但這段程式碼確實能造成大量的記憶體洩漏。並且，Android Lint(Android studio 編譯器的提示) 將會給你下面的警告：

In Android, Handler classes should be static or leaks might occur.

但洩漏到底在哪裡，何時發生? 我們就可以用我們所知道的來確定問題的根源：

1.Android 應用程式首次啟動時，framework將會為application’s main thread 建立一個looper物件。looper實現了一個簡單的message佇列,迴圈的處理message物件。所有的主要application framework事件（例如 activity生命週期方法的呼叫， button的點選事件, 等等） 都包含在Message物件中，message 被新增到looper的message佇列中並且逐個處理。

2.當一個handler在main thread中例項化，它將會和looper’s 訊息佇列關聯。當handler傳送一個message到訊息佇列中，該message物件將會持有handler的引用. 所以,當looper處理該訊息的時候，framework 可以呼叫handler#handler（message）方法

3.在Java中，非靜態內部和匿名類保留對其外部類的隱含引用。但是，靜態內部類將不會。

那麼記憶體洩漏究竟在哪裡呢？這很微妙，我們以下面的程式碼為例：

public class SampleActivity extends Activity {

  private final Handler mLeakyHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      // ...
    }
  };

  @Override
  protected void
 
 onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mLeakyHandler.postDelayed(new Runnable() {
      @Override
      public void run() { /* ... */ }
    }, 1000 * 60 * 10);

    // Go back to the previous Activity.
    finish();
  }
}

當這個activity被銷燬，延遲訊息在被處理之前會繼續在主執行緒的佇列中存活10分鐘。訊息物件將會持有handler引用，而且handler也持有一個隱含的引用外部類（在這個例子中是SampleActivity）。這個引用直到訊息被處理之前將一直保留。注意，在匿名 Runnable 類中的15行也是如此。非靜態的匿名類例項持有一個他們的外部類的隱含引用，所以，context將會洩漏。

要解決這個問題，需要將繼承handler的子類建立成一個新的檔案， 或者使用靜態內部類來代替。靜態內部類不會持有他們的外部類的隱含引用，所以，activity將不會洩漏。如果你需要在handler內部呼叫外部activity的方法，可以在handler持有一個WeakReference 的activity，那麼你講不會意外地洩漏context。為了修復當我們例項化一個匿名Runnable 類時發生的記憶體洩漏，我們使變數成為該類的一個靜態欄位（由於匿名類的靜態例項不包含對外部類的隱含引用）：

public class SampleActivity extends Activity {

  /**
   * Instances of static inner classes do not hold an implicit
   * reference to their outer class.
   */
  private static class MyHandler extends Handler {
    private final WeakReference<SampleActivity> mActivity;

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

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

  private final MyHandler mHandler = new MyHandler(this);

  /**
   * Instances of anonymous classes do not hold an implicit
   * reference to their outer class when they are "static".
   */
  private static final Runnable sRunnable = new Runnable() {
      @Override
      public void run() { /* ... */ }
  };

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mHandler.postDelayed(sRunnable, 1000 * 60 * 10);

    // Go back to the pevious Activity.
    finish();
  }
}

靜態類和非靜態類的區別是微妙的，但是，這是每一個android開發人員需要知道的。
最關鍵的是什麼？如果一個內部類能夠存活的比activity的生命週期還長，應該避免在activity使用非靜態內部類。因此，寧可選擇靜態內部類並在裡面持有一個弱引用的activity。