Android中Handler的正確使用

在Android常用程式設計中，Handler在進行非同步操作並處理返回結果時經常被使用。通常我們的程式碼會這樣實現。

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

但是，其實上面的程式碼導致記憶體洩露，當你使用Android lint工具的話，會得到這樣的警告

In Android, Handler classes should be static or leaks might occur, Messages enqueued on the application thread’s MessageQueue also retain their target Handler. If the Handler is an inner class, its outer class will be retained as well. To avoid leaking the outer class, declare the Handler as a static nested class with a WeakReference to its outer class

<<分析>>
當我們執行了Activity的finish方法，被延遲的訊息會在被處理之前存在於主執行緒訊息佇列中10分鐘，而這個訊息中又包含了Handler的引用，而Handler是一個匿名內部類的例項，其持有外面的SampleActivity的引用，所以這導致了SampleActivity無法回收，進行導致SampleActivity持有的很多資源都無法回收，這就是我們常說的記憶體洩露。
注意上面的new Runnable這裡也是匿名內部類實現的，同樣也會持有SampleActivity的引用，也會阻止SampleActivity被回收。

<<解決>>
避免使用非靜態內部類，繼承Handler時，要麼是放在單獨的類檔案中，要麼就是使用靜態內部類。因為靜態的內部類不會持有外部類的引用，所以不會導致外部類例項的記憶體洩露。當你需要在靜態內部類中呼叫外部的Activity時，我們可以使用弱引用來處理。另外關於同樣也需要將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 previous Activity.
    finish();
  }
}

注意:

1.當一個Android應用啟動的時候，會自動建立一個供應用主執行緒使用的Looper例項。Looper的主要工作就是一個一個處理訊息佇列中的訊息物件。在Android中，所有Android框架的事件（比如Activity的生命週期方法呼叫和按鈕點選等）都是放入到訊息中，然後加入到Looper要處理的訊息佇列中，由Looper負責一條一條地進行處理。主執行緒中的Looper生命週期和當前應用一樣長。
2.當一個Handler在主執行緒進行了初始化之後，我們傳送一個target為這個Handler的訊息到Looper處理的訊息佇列時，實際上已經傳送的訊息已經包含了一個Handler例項的引用，只有這樣Looper在處理到這條訊息時才可以呼叫Handler#handleMessage(Message)完成訊息的正確處理。
3.在Java中，非靜態的內部類和匿名內部類都會隱式地持有其外部類的引用。靜態的內部類不會持有外部類的引用。關於這一內容可以檢視細話Java：”失效”的private修飾符

---

---

接下來就是另闢蹊徑的一種方式了:
實現回撥弱引用的Handler

/**
 * 實現回撥弱引用的Handler
 * 防止由於內部持有導致的記憶體洩露
 * 
 * PS：
 * 1、傳入的Callback不能使用匿名實現的變數，必須與使用這個Handle的物件的生命週期一致，否則會被立即釋放掉了
 * 
 * @author brian512
 */
public class WeakRefHandler extends Handler {
    private WeakReference<Callback> mWeakReference;
    
    public WeakRefHandler(Callback callback) {
        mWeakReference = new WeakReference<Handler.Callback>(callback);
    }
    
    public WeakRefHandler(Callback callback, Looper looper) {
        super(looper);
        mWeakReference = new WeakReference<Handler.Callback>(callback);
    }
    
    @Override
    public void handleMessage(Message msg) {
        if (mWeakReference != null && mWeakReference.get() != null) {
            Callback callback = mWeakReference.get();
            callback.handleMessage(msg);
        }
    }
}

由於是弱引用，當該類需要被回收時，就可以直接被回收掉。
WeakRefHandler的使用時如下：

    private Handler.Callback mCallback = new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            switch(msg.what){
            }
            return true;
        }
    };
    private Handler mHandler = new WeakRefHandler(mCallback);